home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / puma.lha / puma / m2c / C.c next >
C/C++ Source or Header  |  1992-09-25  |  75KB  |  2,760 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_System
  4. #include "System.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_IO
  8. #include "IO.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Tree
  12. #include "Tree.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Positions
  16. #include "Positions.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_IO
  20. #include "IO.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_Strings
  24. #include "Strings.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_StringMem
  28. #include "StringMem.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Idents
  32. #include "Idents.h"
  33. #endif
  34.  
  35. #ifndef DEFINITION_Texts
  36. #include "Texts.h"
  37. #endif
  38.  
  39. #ifndef DEFINITION_Sets
  40. #include "Sets.h"
  41. #endif
  42.  
  43. #ifndef DEFINITION_Semantics
  44. #include "Semantics.h"
  45. #endif
  46.  
  47. #ifndef DEFINITION_Optimize
  48. #include "Optimize.h"
  49. #endif
  50.  
  51. #ifndef DEFINITION_Tree
  52. #include "Tree.h"
  53. #endif
  54.  
  55. #ifndef DEFINITION_C
  56. #include "C.h"
  57. #endif
  58.  
  59. IO_tFile C_yyf;
  60. PROC C_Exit;
  61.  
  62. #define kProcedure    0
  63. #define kFunction    1
  64. #define kPredicate    2
  65. static unsigned char RoutineKind;
  66. static INTEGER WithCount, RuleCount, ListCount;
  67. static CARDINAL i, j;
  68. static Tree_tTree rule, TheClass, InFormals, OutFormals, ReturnFormals, Decls;
  69. static Idents_tIdent TheName;
  70. static BOOLEAN TemposDone;
  71. static void WriteLine ARGS((Positions_tPosition Line));
  72. static void Match ARGS((Tree_tTree t, Tree_tTree Formals));
  73. static void MatchExprs ARGS((Tree_tTree t));
  74. static void MatchExpr ARGS((Tree_tTree t));
  75. static void AssignTempos ARGS((Tree_tTree t));
  76. static void AssignTempo ARGS((Tree_tTree t));
  77. static void AssignFormals ARGS((Tree_tTree t, Tree_tTree Formals));
  78. static void AssignFormal ARGS((Tree_tTree t, Tree_tTree Formals));
  79. static void AssignSubFormals ARGS((Tree_tTree t, Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer));
  80. static void AssignSubFormal ARGS((Tree_tTree t, Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer));
  81. static void BeginFormals ARGS((Tree_tTree Formals));
  82. static void BeginSubFormals ARGS((Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer));
  83. static INTEGER ConsPatterns ARGS((Tree_tTree t, INTEGER ListCount));
  84. static INTEGER ConsTempos ARGS((Tree_tTree t, INTEGER ListCount, BOOLEAN IsRef));
  85. static INTEGER Expressions ARGS((Tree_tTree t, INTEGER ListCount));
  86. static INTEGER Expressions2 ARGS((Tree_tTree t, INTEGER ListCount, Tree_tTree Formals));
  87. static void Expression ARGS((Tree_tTree t));
  88. static Idents_tIdent MakeWith ARGS(());
  89. static void yyAbort ARGS((CHAR yyFunction[], LONGCARD ));
  90. static BOOLEAN yyIsEqual ARGS((BYTE yya[], LONGCARD , BYTE yyb[], LONGCARD ));
  91. struct S_3 {
  92.     union {
  93.         char dummy;
  94.     } U_1;
  95. };
  96. struct S_4 {
  97.     union {
  98.         char dummy;
  99.     } U_1;
  100. };
  101. static void Forward ARGS((Tree_tTree t));
  102. struct S_5 {
  103.     union {
  104.         char dummy;
  105.     } U_1;
  106. };
  107. static void ProcHead1 ARGS((Tree_tTree t));
  108. struct S_6 {
  109.     union {
  110.         char dummy;
  111.     } U_1;
  112. };
  113. static void ProcHead2 ARGS((Tree_tTree t));
  114. struct S_7 {
  115.     union {
  116.         char dummy;
  117.     } U_1;
  118. };
  119. static void ProcHead3 ARGS((Tree_tTree t));
  120. struct S_8 {
  121.     union {
  122.         char dummy;
  123.     } U_1;
  124. };
  125. struct S_9 {
  126.     union {
  127.         struct {
  128.             struct S_10 {
  129.                 Tree_tTree Var;
  130.             } yyR14;
  131.         } V_1;
  132.     } U_1;
  133. };
  134. static void Declare ARGS((Tree_tTree t));
  135. struct S_11 {
  136.     union {
  137.         struct {
  138.             struct S_12 {
  139.                 Tree_tTree Var;
  140.             } yyR2;
  141.         } V_1;
  142.     } U_1;
  143. };
  144. static void Tg1 ARGS((Tree_tTree t));
  145. struct S_13 {
  146.     union {
  147.         char dummy;
  148.     } U_1;
  149. };
  150. static void CommonTestElim ARGS((Tree_tTree t));
  151. struct S_14 {
  152.     union {
  153.         char dummy;
  154.     } U_1;
  155. };
  156. static void Case ARGS((Tree_tTree t));
  157. struct S_15 {
  158.     union {
  159.         struct {
  160.             struct S_16 {
  161.                 CARDINAL n;
  162.             } yyR1;
  163.         } V_1;
  164.     } U_1;
  165. };
  166. static void yyExit ARGS(());
  167.  
  168.  
  169. static void WriteLine
  170. # ifdef __STDC__
  171. (Positions_tPosition Line)
  172. # else
  173. (Line)
  174. Positions_tPosition Line;
  175. # endif
  176. {
  177.   if (Line.Line != 0) {
  178.     if (Sets_IsElement(ORD('6'), &Tree_Options)) {
  179.       IO_WriteS(Tree_f, (STRING)"# line ", 7L);
  180.       Tree_WN((LONGINT)Line.Line);
  181.       IO_WriteS(Tree_f, (STRING)" \"", 2L);
  182.       IO_WriteS(Tree_f, Tree_SourceFile.A, 256L);
  183.       IO_WriteS(Tree_f, (STRING)"\"", 1L);
  184.       IO_WriteNl(Tree_f);
  185.     } else {
  186.       IO_WriteS(Tree_f, (STRING)"/* line ", 8L);
  187.       Tree_WN((LONGINT)Line.Line);
  188.       IO_WriteS(Tree_f, (STRING)" \"", 2L);
  189.       IO_WriteS(Tree_f, Tree_SourceFile.A, 256L);
  190.       IO_WriteS(Tree_f, (STRING)"\" */", 4L);
  191.       IO_WriteNl(Tree_f);
  192.     }
  193.   }
  194. }
  195.  
  196. static void Match
  197. # ifdef __STDC__
  198. (Tree_tTree t, Tree_tTree Formals)
  199. # else
  200. (t, Formals)
  201. Tree_tTree t, Formals;
  202. # endif
  203. {
  204.   Idents_tIdent TreeName;
  205.   Tree_tTree Pattern;
  206.  
  207.   if (t->U_1.V_1.Kind == Tree_NoPattern || Formals->U_1.V_1.Kind != Tree_Formal) {
  208.     return;
  209.   }
  210.   Pattern = t->U_1.V_45.OnePattern.Pattern;
  211.   switch (Pattern->U_1.V_1.Kind) {
  212.   case Tree_Decompose:;
  213.     {
  214.       register Tree_yDecompose *W_1 = &Pattern->U_1.V_50.Decompose;
  215.  
  216.       TreeName = W_1->Object->U_1.V_5.Class.TypeDesc->U_1.V_89.NodeTypes.TreeName->U_1.V_29.TreeName.Name;
  217.       if (Formals->U_1.V_86.Formal.TypeDesc->U_1.V_1.Kind == Tree_UserType || Sets_IsNotEqual(W_1->Object->U_1.V_5.Class.TypeDesc->U_1.V_89.NodeTypes.Types, Formals->U_1.V_86.Formal.TypeDesc->U_1.V_89.NodeTypes.Types)) {
  218.         if (W_1->Object->U_1.V_5.Class.Extensions->U_1.V_1.Kind == Tree_NoClass) {
  219.           IO_WriteS(Tree_f, (STRING)"   if (", 7L);
  220.           C_ImplC(W_1->Path);
  221.           IO_WriteS(Tree_f, (STRING)"->Kind != k", 11L);
  222.           Tree_WI(W_1->Object->U_1.V_5.Class.Name);
  223.         } else {
  224.           IO_WriteS(Tree_f, (STRING)"   if (! ", 9L);
  225.           Tree_WI(TreeName);
  226.           IO_WriteS(Tree_f, (STRING)"_IsType (", 9L);
  227.           C_ImplC(W_1->Path);
  228.           IO_WriteS(Tree_f, (STRING)", k", 3L);
  229.           Tree_WI(W_1->Object->U_1.V_5.Class.Name);
  230.           IO_WriteS(Tree_f, (STRING)")", 1L);
  231.         }
  232.         IO_WriteS(Tree_f, (STRING)") goto yyL", 10L);
  233.         Tree_WN(RuleCount);
  234.         IO_WriteS(Tree_f, (STRING)";", 1L);
  235.         IO_WriteNl(Tree_f);
  236.       }
  237.       Match(W_1->Patterns, W_1->Object->U_1.V_5.Class.Formals);
  238.     }
  239.     break;
  240.   case Tree_VarDef:;
  241.     {
  242.       register Tree_yVarDef *W_2 = &Pattern->U_1.V_51.VarDef;
  243.  
  244.       if (W_2->Object != Tree_NoTree) {
  245.         {
  246.           register Tree_yFormal *W_3 = &W_2->Object->U_1.V_86.Formal;
  247.  
  248.           IO_WriteS(Tree_f, (STRING)"   if (! (equal", 15L);
  249.           C_DefC(W_3->TypeDesc);
  250.           IO_WriteS(Tree_f, (STRING)" (", 2L);
  251.           C_ImplC(W_3->Path);
  252.           IO_WriteS(Tree_f, (STRING)", ", 2L);
  253.           C_ImplC(Pattern->U_1.V_51.VarDef.Path);
  254.           IO_WriteS(Tree_f, (STRING)"))) goto yyL", 12L);
  255.           Tree_WN(RuleCount);
  256.           IO_WriteS(Tree_f, (STRING)";", 1L);
  257.           IO_WriteNl(Tree_f);
  258.         }
  259.       }
  260.     }
  261.     break;
  262.   case Tree_NilTest:;
  263.     IO_WriteS(Tree_f, (STRING)"   if (", 7L);
  264.     C_ImplC(Pattern->U_1.V_52.NilTest.Path);
  265.     IO_WriteS(Tree_f, (STRING)" != NULL) goto yyL", 18L);
  266.     Tree_WN(RuleCount);
  267.     IO_WriteS(Tree_f, (STRING)";", 1L);
  268.     IO_WriteNl(Tree_f);
  269.     break;
  270.   case Tree_DontCare1:;
  271.     break;
  272.   case Tree_DontCare:;
  273.     return;
  274.     break;
  275.   case Tree_Value:;
  276.     {
  277.       register Tree_yValue *W_4 = &Pattern->U_1.V_55.Value;
  278.  
  279.       AssignTempo(W_4->Expr);
  280.       if (Formals->U_1.V_86.Formal.TypeDesc->U_1.V_1.Kind == Tree_UserType && Sets_IsElement((LONGCARD)Formals->U_1.V_86.Formal.TypeDesc->U_1.V_90.UserType.Type, &Semantics_UserTypes)) {
  281.         IO_WriteS(Tree_f, (STRING)"  {", 3L);
  282.         C_DefC(Formals->U_1.V_86.Formal.TypeDesc);
  283.         IO_WriteS(Tree_f, (STRING)" yyT; yyT = ", 12L);
  284.         Expression(W_4->Expr);
  285.         IO_WriteS(Tree_f, (STRING)";", 1L);
  286.         IO_WriteNl(Tree_f);
  287.         IO_WriteS(Tree_f, (STRING)"   if (! (equal", 15L);
  288.         C_DefC(Formals->U_1.V_86.Formal.TypeDesc);
  289.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  290.         C_ImplC(W_4->Path);
  291.         IO_WriteS(Tree_f, (STRING)", yyT))) goto yyL", 17L);
  292.         Tree_WN(RuleCount);
  293.         IO_WriteS(Tree_f, (STRING)";", 1L);
  294.         IO_WriteNl(Tree_f);
  295.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  296.         IO_WriteNl(Tree_f);
  297.       } else {
  298.         IO_WriteS(Tree_f, (STRING)"   if (! (equal", 15L);
  299.         C_DefC(Formals->U_1.V_86.Formal.TypeDesc);
  300.         IO_WriteS(Tree_f, (STRING)" (", 2L);
  301.         C_ImplC(W_4->Path);
  302.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  303.         Expression(W_4->Expr);
  304.         IO_WriteS(Tree_f, (STRING)"))) goto yyL", 12L);
  305.         Tree_WN(RuleCount);
  306.         IO_WriteS(Tree_f, (STRING)";", 1L);
  307.         IO_WriteNl(Tree_f);
  308.       }
  309.       MatchExpr(W_4->Expr);
  310.     }
  311.     break;
  312.   }
  313.   Match(t->U_1.V_45.OnePattern.Next, Formals->U_1.V_86.Formal.Next);
  314. }
  315.  
  316. static void MatchExprs
  317. # ifdef __STDC__
  318. (Tree_tTree t)
  319. # else
  320. (t)
  321. Tree_tTree t;
  322. # endif
  323. {
  324.   if (t->U_1.V_1.Kind == Tree_NoExpr) {
  325.     return;
  326.   }
  327.   if (t->U_1.V_58.OneExpr.Expr->U_1.V_1.Kind == Tree_DontCare) {
  328.     return;
  329.   }
  330.   MatchExpr(t->U_1.V_58.OneExpr.Expr);
  331.   MatchExprs(t->U_1.V_58.OneExpr.Next);
  332. }
  333.  
  334. static void MatchExpr
  335. # ifdef __STDC__
  336. (Tree_tTree t)
  337. # else
  338. (t)
  339. Tree_tTree t;
  340. # endif
  341. {
  342.   switch (t->U_1.V_1.Kind) {
  343.   case Tree_Compose:;
  344.     MatchExprs(t->U_1.V_61.Compose.Exprs);
  345.     break;
  346.   case Tree_VarUse:;
  347.     break;
  348.   case Tree_Nil:;
  349.     break;
  350.   case Tree_DontCare1:;
  351.     break;
  352.   case Tree_TargetExpr:;
  353.     break;
  354.   case Tree_StringExpr:;
  355.     break;
  356.   case Tree_AttrDesc:;
  357.     break;
  358.   case Tree_Call:;
  359.     {
  360.       register Tree_yCall *W_5 = &t->U_1.V_65.Call;
  361.  
  362.       MatchExpr(W_5->Expr);
  363.       MatchExprs(W_5->Exprs);
  364.       if (W_5->Object != Tree_NoTree) {
  365.         Match(W_5->Patterns, W_5->Object->U_1.V_32.Routine.OutForm);
  366.       }
  367.     }
  368.     break;
  369.   case Tree_Binary:;
  370.     {
  371.       register Tree_yBinary *W_6 = &t->U_1.V_66.Binary;
  372.  
  373.       MatchExpr(W_6->Lop);
  374.       MatchExpr(W_6->Rop);
  375.     }
  376.     break;
  377.   case Tree_PreOperator:;
  378.   case Tree_PostOperator:;
  379.     MatchExpr(t->U_1.V_67.PreOperator.Expr);
  380.     break;
  381.   case Tree_Index:;
  382.     MatchExpr(t->U_1.V_69.Index.Expr);
  383.     MatchExprs(t->U_1.V_69.Index.Exprs);
  384.     break;
  385.   case Tree_Parents:;
  386.     MatchExpr(t->U_1.V_70.Parents.Expr);
  387.     break;
  388.   }
  389. }
  390.  
  391. static void AssignTempos
  392. # ifdef __STDC__
  393. (Tree_tTree t)
  394. # else
  395. (t)
  396. Tree_tTree t;
  397. # endif
  398. {
  399.   if (t->U_1.V_1.Kind == Tree_NoExpr) {
  400.     return;
  401.   }
  402.   if (t->U_1.V_58.OneExpr.Expr->U_1.V_1.Kind == Tree_DontCare) {
  403.     return;
  404.   }
  405.   AssignTempo(t->U_1.V_58.OneExpr.Expr);
  406.   AssignTempos(t->U_1.V_58.OneExpr.Next);
  407. }
  408.  
  409. static void AssignTempo
  410. # ifdef __STDC__
  411. (Tree_tTree t)
  412. # else
  413. (t)
  414. Tree_tTree t;
  415. # endif
  416. {
  417.   Idents_tIdent TreeName;
  418.  
  419.   switch (t->U_1.V_1.Kind) {
  420.   case Tree_Compose:;
  421.     {
  422.       register Tree_yCompose *W_7 = &t->U_1.V_61.Compose;
  423.  
  424.       TreeName = W_7->Object->U_1.V_5.Class.TypeDesc->U_1.V_89.NodeTypes.TreeName->U_1.V_29.TreeName.Name;
  425.       IO_WriteS(Tree_f, (STRING)"   yyALLOC (t", 13L);
  426.       Tree_WI(TreeName);
  427.       IO_WriteS(Tree_f, (STRING)",", 1L);
  428.       Tree_WI(TreeName);
  429.       IO_WriteS(Tree_f, (STRING)"_PoolFreePtr,", 13L);
  430.       Tree_WI(TreeName);
  431.       IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr,", 12L);
  432.       Tree_WI(TreeName);
  433.       IO_WriteS(Tree_f, (STRING)"_Alloc,", 7L);
  434.       Tree_WI(TreeName);
  435.       IO_WriteS(Tree_f, (STRING)"_NodeSize,Make", 14L);
  436.       Tree_WI(TreeName);
  437.       IO_WriteS(Tree_f, (STRING)",", 1L);
  438.       Tree_WI(W_7->Tempo);
  439.       IO_WriteS(Tree_f, (STRING)",k", 2L);
  440.       Tree_WI(W_7->Object->U_1.V_5.Class.Name);
  441.       IO_WriteS(Tree_f, (STRING)")", 1L);
  442.       IO_WriteNl(Tree_f);
  443.       AssignSubFormals(W_7->Exprs, W_7->Object->U_1.V_5.Class.Formals, W_7->Tempo, W_7->Object->U_1.V_5.Class.Name);
  444.     }
  445.     break;
  446.   case Tree_VarUse:;
  447.     break;
  448.   case Tree_Nil:;
  449.     break;
  450.   case Tree_DontCare1:;
  451.     break;
  452.   case Tree_TargetExpr:;
  453.     break;
  454.   case Tree_StringExpr:;
  455.     break;
  456.   case Tree_AttrDesc:;
  457.     break;
  458.   case Tree_Call:;
  459.     {
  460.       register Tree_yCall *W_8 = &t->U_1.V_65.Call;
  461.  
  462.       AssignTempo(W_8->Expr);
  463.       AssignTempos(W_8->Exprs);
  464.     }
  465.     break;
  466.   case Tree_Binary:;
  467.     {
  468.       register Tree_yBinary *W_9 = &t->U_1.V_66.Binary;
  469.  
  470.       AssignTempo(W_9->Lop);
  471.       AssignTempo(W_9->Rop);
  472.     }
  473.     break;
  474.   case Tree_PreOperator:;
  475.   case Tree_PostOperator:;
  476.     AssignTempo(t->U_1.V_67.PreOperator.Expr);
  477.     break;
  478.   case Tree_Index:;
  479.     AssignTempo(t->U_1.V_69.Index.Expr);
  480.     AssignTempos(t->U_1.V_69.Index.Exprs);
  481.     break;
  482.   case Tree_Parents:;
  483.     AssignTempo(t->U_1.V_70.Parents.Expr);
  484.     break;
  485.   }
  486. }
  487.  
  488. static void AssignFormals
  489. # ifdef __STDC__
  490. (Tree_tTree t, Tree_tTree Formals)
  491. # else
  492. (t, Formals)
  493. Tree_tTree t, Formals;
  494. # endif
  495. {
  496.   if (t->U_1.V_1.Kind == Tree_NoExpr || Formals->U_1.V_1.Kind != Tree_Formal) {
  497.     return;
  498.   }
  499.   if (t->U_1.V_58.OneExpr.Expr->U_1.V_1.Kind == Tree_DontCare) {
  500.     BeginFormals(Formals);
  501.     return;
  502.   }
  503.   AssignFormal(t->U_1.V_58.OneExpr.Expr, Formals);
  504.   MatchExpr(t->U_1.V_58.OneExpr.Expr);
  505.   AssignFormals(t->U_1.V_58.OneExpr.Next, Formals->U_1.V_86.Formal.Next);
  506. }
  507.  
  508. static void AssignFormal
  509. # ifdef __STDC__
  510. (Tree_tTree t, Tree_tTree Formals)
  511. # else
  512. (t, Formals)
  513. Tree_tTree t, Formals;
  514. # endif
  515. {
  516.   Idents_tIdent TreeName, With;
  517.  
  518.   if (t->U_1.V_1.Kind == Tree_Compose) {
  519.     {
  520.       register Tree_yCompose *W_10 = &t->U_1.V_61.Compose;
  521.  
  522.       TreeName = W_10->Object->U_1.V_5.Class.TypeDesc->U_1.V_89.NodeTypes.TreeName->U_1.V_29.TreeName.Name;
  523.       With = MakeWith();
  524.       IO_WriteS(Tree_f, (STRING)"   {register t", 14L);
  525.       Tree_WI(TreeName);
  526.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  527.       Tree_WI(With);
  528.       IO_WriteS(Tree_f, (STRING)";", 1L);
  529.       IO_WriteNl(Tree_f);
  530.       IO_WriteS(Tree_f, (STRING)"    yyALLOC (t", 14L);
  531.       Tree_WI(TreeName);
  532.       IO_WriteS(Tree_f, (STRING)",", 1L);
  533.       Tree_WI(TreeName);
  534.       IO_WriteS(Tree_f, (STRING)"_PoolFreePtr,", 13L);
  535.       Tree_WI(TreeName);
  536.       IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr,", 12L);
  537.       Tree_WI(TreeName);
  538.       IO_WriteS(Tree_f, (STRING)"_Alloc,", 7L);
  539.       Tree_WI(TreeName);
  540.       IO_WriteS(Tree_f, (STRING)"_NodeSize,Make", 14L);
  541.       Tree_WI(TreeName);
  542.       IO_WriteS(Tree_f, (STRING)",", 1L);
  543.       Tree_WI(With);
  544.       IO_WriteS(Tree_f, (STRING)",k", 2L);
  545.       Tree_WI(W_10->Object->U_1.V_5.Class.Name);
  546.       IO_WriteS(Tree_f, (STRING)")", 1L);
  547.       IO_WriteNl(Tree_f);
  548.       IO_WriteS(Tree_f, (STRING)"    * ", 6L);
  549.       Tree_WI(Formals->U_1.V_86.Formal.Name);
  550.       IO_WriteS(Tree_f, (STRING)" = ", 3L);
  551.       Tree_WI(With);
  552.       IO_WriteS(Tree_f, (STRING)";", 1L);
  553.       IO_WriteNl(Tree_f);
  554.       AssignSubFormals(W_10->Exprs, W_10->Object->U_1.V_5.Class.Formals, With, W_10->Object->U_1.V_5.Class.Name);
  555.       IO_WriteS(Tree_f, (STRING)"   }", 4L);
  556.       IO_WriteNl(Tree_f);
  557.     }
  558.   } else {
  559.     AssignTempo(t);
  560.   }
  561.   switch (t->U_1.V_1.Kind) {
  562.   case Tree_VarUse:;
  563.   case Tree_Nil:;
  564.   case Tree_Call:;
  565.   case Tree_Binary:;
  566.   case Tree_PreOperator:;
  567.   case Tree_PostOperator:;
  568.   case Tree_Index:;
  569.   case Tree_Parents:;
  570.   case Tree_TargetExpr:;
  571.   case Tree_StringExpr:;
  572.   case Tree_AttrDesc:;
  573.     IO_WriteS(Tree_f, (STRING)"   * ", 5L);
  574.     Tree_WI(Formals->U_1.V_86.Formal.Name);
  575.     IO_WriteS(Tree_f, (STRING)" = ", 3L);
  576.     Expression(t);
  577.     IO_WriteS(Tree_f, (STRING)";", 1L);
  578.     IO_WriteNl(Tree_f);
  579.     break;
  580.   case Tree_DontCare1:;
  581.     IO_WriteS(Tree_f, (STRING)"    begin", 9L);
  582.     C_DefC(Formals->U_1.V_86.Formal.TypeDesc);
  583.     IO_WriteS(Tree_f, (STRING)" (* ", 4L);
  584.     Tree_WI(Formals->U_1.V_86.Formal.Name);
  585.     IO_WriteS(Tree_f, (STRING)")", 1L);
  586.     IO_WriteNl(Tree_f);
  587.     break;
  588.   default :
  589.     break;
  590.   }
  591. }
  592.  
  593. static void AssignSubFormals
  594. # ifdef __STDC__
  595. (Tree_tTree t, Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer)
  596. # else
  597. (t, Formals, PrevWith, Composer)
  598. Tree_tTree t, Formals;
  599. Idents_tIdent PrevWith, Composer;
  600. # endif
  601. {
  602.   if (t->U_1.V_1.Kind == Tree_NoExpr || Formals->U_1.V_1.Kind != Tree_Formal) {
  603.     return;
  604.   }
  605.   if (t->U_1.V_58.OneExpr.Expr->U_1.V_1.Kind == Tree_DontCare) {
  606.     BeginSubFormals(Formals, PrevWith, Composer);
  607.     return;
  608.   }
  609.   AssignSubFormal(t->U_1.V_58.OneExpr.Expr, Formals, PrevWith, Composer);
  610.   AssignSubFormals(t->U_1.V_58.OneExpr.Next, Formals->U_1.V_86.Formal.Next, PrevWith, Composer);
  611. }
  612.  
  613. static void AssignSubFormal
  614. # ifdef __STDC__
  615. (Tree_tTree t, Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer)
  616. # else
  617. (t, Formals, PrevWith, Composer)
  618. Tree_tTree t, Formals;
  619. Idents_tIdent PrevWith, Composer;
  620. # endif
  621. {
  622.   Idents_tIdent TreeName, With;
  623.  
  624.   if (t->U_1.V_1.Kind == Tree_Compose) {
  625.     {
  626.       register Tree_yCompose *W_11 = &t->U_1.V_61.Compose;
  627.  
  628.       TreeName = W_11->Object->U_1.V_5.Class.TypeDesc->U_1.V_89.NodeTypes.TreeName->U_1.V_29.TreeName.Name;
  629.       With = MakeWith();
  630.       IO_WriteS(Tree_f, (STRING)"   {register t", 14L);
  631.       Tree_WI(TreeName);
  632.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  633.       Tree_WI(With);
  634.       IO_WriteS(Tree_f, (STRING)";", 1L);
  635.       IO_WriteNl(Tree_f);
  636.       IO_WriteS(Tree_f, (STRING)"    yyALLOC (t", 14L);
  637.       Tree_WI(TreeName);
  638.       IO_WriteS(Tree_f, (STRING)",", 1L);
  639.       Tree_WI(TreeName);
  640.       IO_WriteS(Tree_f, (STRING)"_PoolFreePtr,", 13L);
  641.       Tree_WI(TreeName);
  642.       IO_WriteS(Tree_f, (STRING)"_PoolMaxPtr,", 12L);
  643.       Tree_WI(TreeName);
  644.       IO_WriteS(Tree_f, (STRING)"_Alloc,", 7L);
  645.       Tree_WI(TreeName);
  646.       IO_WriteS(Tree_f, (STRING)"_NodeSize,Make", 14L);
  647.       Tree_WI(TreeName);
  648.       IO_WriteS(Tree_f, (STRING)",", 1L);
  649.       Tree_WI(With);
  650.       IO_WriteS(Tree_f, (STRING)",k", 2L);
  651.       Tree_WI(W_11->Object->U_1.V_5.Class.Name);
  652.       IO_WriteS(Tree_f, (STRING)")", 1L);
  653.       IO_WriteNl(Tree_f);
  654.       IO_WriteS(Tree_f, (STRING)"    ", 4L);
  655.       Tree_WI(PrevWith);
  656.       IO_WriteS(Tree_f, (STRING)"->", 2L);
  657.       Tree_WI(Composer);
  658.       IO_WriteS(Tree_f, (STRING)".", 1L);
  659.       Tree_WI(Formals->U_1.V_86.Formal.Name);
  660.       IO_WriteS(Tree_f, (STRING)" = ", 3L);
  661.       Tree_WI(With);
  662.       IO_WriteS(Tree_f, (STRING)";", 1L);
  663.       IO_WriteNl(Tree_f);
  664.       AssignSubFormals(W_11->Exprs, W_11->Object->U_1.V_5.Class.Formals, With, W_11->Object->U_1.V_5.Class.Name);
  665.       IO_WriteS(Tree_f, (STRING)"   }", 4L);
  666.       IO_WriteNl(Tree_f);
  667.     }
  668.   } else {
  669.     AssignTempo(t);
  670.   }
  671.   switch (t->U_1.V_1.Kind) {
  672.   case Tree_VarUse:;
  673.   case Tree_Nil:;
  674.   case Tree_Call:;
  675.   case Tree_Binary:;
  676.   case Tree_PreOperator:;
  677.   case Tree_PostOperator:;
  678.   case Tree_Index:;
  679.   case Tree_Parents:;
  680.   case Tree_TargetExpr:;
  681.   case Tree_StringExpr:;
  682.   case Tree_AttrDesc:;
  683.     IO_WriteS(Tree_f, (STRING)"    ", 4L);
  684.     Tree_WI(PrevWith);
  685.     IO_WriteS(Tree_f, (STRING)"->", 2L);
  686.     Tree_WI(Composer);
  687.     IO_WriteS(Tree_f, (STRING)".", 1L);
  688.     Tree_WI(Formals->U_1.V_86.Formal.Name);
  689.     IO_WriteS(Tree_f, (STRING)" = ", 3L);
  690.     Expression(t);
  691.     IO_WriteS(Tree_f, (STRING)";", 1L);
  692.     IO_WriteNl(Tree_f);
  693.     break;
  694.   case Tree_DontCare1:;
  695.     IO_WriteS(Tree_f, (STRING)"    begin", 9L);
  696.     C_DefC(Formals->U_1.V_86.Formal.TypeDesc);
  697.     IO_WriteS(Tree_f, (STRING)" (", 2L);
  698.     Tree_WI(PrevWith);
  699.     IO_WriteS(Tree_f, (STRING)"->", 2L);
  700.     Tree_WI(Composer);
  701.     IO_WriteS(Tree_f, (STRING)".", 1L);
  702.     Tree_WI(Formals->U_1.V_86.Formal.Name);
  703.     IO_WriteS(Tree_f, (STRING)")", 1L);
  704.     IO_WriteNl(Tree_f);
  705.     break;
  706.   default :
  707.     break;
  708.   }
  709. }
  710.  
  711. static void BeginFormals
  712. # ifdef __STDC__
  713. (Tree_tTree Formals)
  714. # else
  715. (Formals)
  716. Tree_tTree Formals;
  717. # endif
  718. {
  719.   if (Formals->U_1.V_1.Kind == Tree_Formal) {
  720.     {
  721.       register Tree_yFormal *W_12 = &Formals->U_1.V_86.Formal;
  722.  
  723.       IO_WriteS(Tree_f, (STRING)"    begin", 9L);
  724.       C_DefC(W_12->TypeDesc);
  725.       IO_WriteS(Tree_f, (STRING)" (* ", 4L);
  726.       Tree_WI(W_12->Name);
  727.       IO_WriteS(Tree_f, (STRING)")", 1L);
  728.       IO_WriteNl(Tree_f);
  729.       BeginFormals(W_12->Next);
  730.     }
  731.   }
  732. }
  733.  
  734. static void BeginSubFormals
  735. # ifdef __STDC__
  736. (Tree_tTree Formals, Idents_tIdent PrevWith, Idents_tIdent Composer)
  737. # else
  738. (Formals, PrevWith, Composer)
  739. Tree_tTree Formals;
  740. Idents_tIdent PrevWith, Composer;
  741. # endif
  742. {
  743.   if (Formals->U_1.V_1.Kind == Tree_Formal) {
  744.     {
  745.       register Tree_yFormal *W_13 = &Formals->U_1.V_86.Formal;
  746.  
  747.       IO_WriteS(Tree_f, (STRING)"    begin", 9L);
  748.       C_DefC(W_13->TypeDesc);
  749.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  750.       Tree_WI(PrevWith);
  751.       IO_WriteS(Tree_f, (STRING)"->", 2L);
  752.       Tree_WI(Composer);
  753.       IO_WriteS(Tree_f, (STRING)".", 1L);
  754.       Tree_WI(W_13->Name);
  755.       IO_WriteS(Tree_f, (STRING)")", 1L);
  756.       IO_WriteNl(Tree_f);
  757.       BeginSubFormals(W_13->Next, PrevWith, Composer);
  758.     }
  759.   }
  760. }
  761.  
  762. static INTEGER ConsPatterns
  763. # ifdef __STDC__
  764. (Tree_tTree t, INTEGER ListCount)
  765. # else
  766. (t, ListCount)
  767. Tree_tTree t;
  768. INTEGER ListCount;
  769. # endif
  770. {
  771.   if (t->U_1.V_1.Kind == Tree_NoPattern) {
  772.     return ListCount;
  773.   }
  774.   {
  775.     register Tree_yOnePattern *W_14 = &t->U_1.V_45.OnePattern;
  776.  
  777.     if (W_14->Pattern->U_1.V_1.Kind == Tree_DontCare) {
  778.       return ConsTempos(W_14->Pattern->U_1.V_54.DontCare.Tempos, ListCount, TRUE);
  779.     } else {
  780.       if (ListCount > 0) {
  781.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  782.       }
  783.       IO_WriteS(Tree_f, (STRING)"& ", 2L);
  784.       Tree_WI(W_14->Pattern->U_1.V_49.Pattern.Tempo);
  785.       return ConsPatterns(W_14->Next, ListCount + 1);
  786.     }
  787.   }
  788. }
  789.  
  790. static INTEGER ConsTempos
  791. # ifdef __STDC__
  792. (Tree_tTree t, INTEGER ListCount, BOOLEAN IsRef)
  793. # else
  794. (t, ListCount, IsRef)
  795. Tree_tTree t;
  796. INTEGER ListCount;
  797. BOOLEAN IsRef;
  798. # endif
  799. {
  800.   if (t->U_1.V_1.Kind == Tree_Formal) {
  801.     if (ListCount > 0) {
  802.       IO_WriteS(Tree_f, (STRING)", ", 2L);
  803.     }
  804.     if (IsRef) {
  805.       IO_WriteS(Tree_f, (STRING)"& ", 2L);
  806.     }
  807.     Tree_WI(t->U_1.V_86.Formal.Name);
  808.     return ConsTempos(t->U_1.V_86.Formal.Next, ListCount + 1, IsRef);
  809.   } else {
  810.     return ListCount;
  811.   }
  812. }
  813.  
  814. static INTEGER Expressions
  815. # ifdef __STDC__
  816. (Tree_tTree t, INTEGER ListCount)
  817. # else
  818. (t, ListCount)
  819. Tree_tTree t;
  820. INTEGER ListCount;
  821. # endif
  822. {
  823.   if (t->U_1.V_1.Kind == Tree_NoExpr) {
  824.     return ListCount;
  825.   }
  826.   {
  827.     register Tree_yOneExpr *W_15 = &t->U_1.V_58.OneExpr;
  828.  
  829.     if (W_15->Expr->U_1.V_1.Kind == Tree_DontCare) {
  830.       return ConsTempos(W_15->Expr->U_1.V_54.DontCare.Tempos, ListCount, FALSE);
  831.     } else {
  832.       if (ListCount > 0) {
  833.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  834.       }
  835.       Expression(W_15->Expr);
  836.       return Expressions(W_15->Next, ListCount + 1);
  837.     }
  838.   }
  839. }
  840.  
  841. static INTEGER Expressions2
  842. # ifdef __STDC__
  843. (Tree_tTree t, INTEGER ListCount, Tree_tTree Formals)
  844. # else
  845. (t, ListCount, Formals)
  846. Tree_tTree t;
  847. INTEGER ListCount;
  848. Tree_tTree Formals;
  849. # endif
  850. {
  851.   if (t->U_1.V_1.Kind == Tree_NoExpr) {
  852.     return ListCount;
  853.   }
  854.   {
  855.     register Tree_yOneExpr *W_16 = &t->U_1.V_58.OneExpr;
  856.  
  857.     if (W_16->Expr->U_1.V_1.Kind == Tree_DontCare) {
  858.       return ConsTempos(W_16->Expr->U_1.V_54.DontCare.Tempos, ListCount, FALSE);
  859.     } else {
  860.       if (ListCount > 0) {
  861.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  862.       }
  863.       if (Formals->U_1.V_86.Formal.Path->U_1.V_92.Var.IsOutput) {
  864.         IO_WriteS(Tree_f, (STRING)"& ", 2L);
  865.       }
  866.       Expression(W_16->Expr);
  867.       return Expressions2(W_16->Next, ListCount + 1, Formals->U_1.V_86.Formal.Next);
  868.     }
  869.   }
  870. }
  871.  
  872. static void Expression
  873. # ifdef __STDC__
  874. (Tree_tTree t)
  875. # else
  876. (t)
  877. Tree_tTree t;
  878. # endif
  879. {
  880.   switch (t->U_1.V_1.Kind) {
  881.   case Tree_Compose:;
  882.     Tree_WI(t->U_1.V_61.Compose.Tempo);
  883.     break;
  884.   case Tree_Nil:;
  885.     IO_WriteS(Tree_f, (STRING)"NULL", 4L);
  886.     break;
  887.   case Tree_VarUse:;
  888.     {
  889.       register Tree_yVarUse *W_17 = &t->U_1.V_62.VarUse;
  890.  
  891.       if (W_17->Object != Tree_NoTree) {
  892.         C_ImplC(W_17->Object->U_1.V_86.Formal.Path);
  893.       } else {
  894.         Tree_WI(W_17->Name);
  895.       }
  896.     }
  897.     break;
  898.   case Tree_DontCare1:;
  899.     Tree_WI(t->U_1.V_53.DontCare1.Tempo);
  900.     break;
  901.   case Tree_Call:;
  902.     {
  903.       register Tree_yCall *W_18 = &t->U_1.V_65.Call;
  904.  
  905.       Expression(W_18->Expr);
  906.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  907.       if (W_18->Object != Tree_NoTree) {
  908.         ListCount = Expressions2(W_18->Exprs, 0L, W_18->Object->U_1.V_32.Routine.InForm);
  909.         ListCount = ConsPatterns(W_18->Patterns, ListCount);
  910.       } else {
  911.         ListCount = Expressions(W_18->Exprs, 0L);
  912.         ListCount = Expressions(W_18->Patterns, ListCount);
  913.       }
  914.       IO_WriteS(Tree_f, (STRING)")", 1L);
  915.     }
  916.     break;
  917.   case Tree_Binary:;
  918.     {
  919.       register Tree_yBinary *W_19 = &t->U_1.V_66.Binary;
  920.  
  921.       Expression(W_19->Lop);
  922.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  923.       Tree_WI(W_19->Operator);
  924.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  925.       Expression(W_19->Rop);
  926.     }
  927.     break;
  928.   case Tree_PreOperator:;
  929.     Tree_WI(t->U_1.V_67.PreOperator.Operator);
  930.     IO_WriteS(Tree_f, (STRING)" ", 1L);
  931.     Expression(t->U_1.V_67.PreOperator.Expr);
  932.     break;
  933.   case Tree_PostOperator:;
  934.     Expression(t->U_1.V_68.PostOperator.Expr);
  935.     IO_WriteS(Tree_f, (STRING)" ", 1L);
  936.     Tree_WI(t->U_1.V_68.PostOperator.Operator);
  937.     break;
  938.   case Tree_Index:;
  939.     Expression(t->U_1.V_69.Index.Expr);
  940.     IO_WriteS(Tree_f, (STRING)" [", 2L);
  941.     ListCount = Expressions(t->U_1.V_69.Index.Exprs, 0L);
  942.     IO_WriteS(Tree_f, (STRING)"]", 1L);
  943.     break;
  944.   case Tree_Parents:;
  945.     IO_WriteS(Tree_f, (STRING)"(", 1L);
  946.     Expression(t->U_1.V_70.Parents.Expr);
  947.     IO_WriteS(Tree_f, (STRING)")", 1L);
  948.     break;
  949.   case Tree_TargetExpr:;
  950.     C_ImplC(t->U_1.V_71.TargetExpr.Expr);
  951.     break;
  952.   case Tree_StringExpr:;
  953.     StringMem_WriteString(Tree_f, t->U_1.V_72.StringExpr.String);
  954.     break;
  955.   case Tree_AttrDesc:;
  956.     {
  957.       register Tree_yAttrDesc *W_20 = &t->U_1.V_63.AttrDesc;
  958.  
  959.       C_ImplC(W_20->Object->U_1.V_86.Formal.Path);
  960.       IO_WriteS(Tree_f, (STRING)"->", 2L);
  961.       Tree_WI(W_20->Type);
  962.       IO_WriteS(Tree_f, (STRING)".", 1L);
  963.       Tree_WI(W_20->Attribute);
  964.     }
  965.     break;
  966.   }
  967. }
  968.  
  969. static Idents_tIdent MakeWith
  970. # ifdef __STDC__
  971. ()
  972. # else
  973. ()
  974. # endif
  975. {
  976.   Strings_tString String1, String2;
  977.  
  978.   INC(WithCount);
  979.   Strings_ArrayToString((STRING)"yyW", 3L, &String1);
  980.   Strings_IntToString(WithCount, &String2);
  981.   Strings_Concatenate(&String1, &String2);
  982.   return Idents_MakeIdent(&String1);
  983. }
  984.  
  985. static void yyAbort
  986. # ifdef __STDC__
  987. (CHAR yyFunction[], LONGCARD O_1)
  988. # else
  989. (yyFunction, O_1)
  990. CHAR yyFunction[];
  991. LONGCARD O_1;
  992. # endif
  993. {
  994.   OPEN_ARRAY_LOCALS
  995.  
  996.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  997.   COPY_OPEN_ARRAY(yyFunction, O_1, CHAR)
  998.   IO_WriteS((System_tFile)IO_StdError, (STRING)"Error: module C, routine ", 25L);
  999.   IO_WriteS((System_tFile)IO_StdError, yyFunction, O_1);
  1000.   IO_WriteS((System_tFile)IO_StdError, (STRING)" failed", 7L);
  1001.   IO_WriteNl((System_tFile)IO_StdError);
  1002.   (*C_Exit)();
  1003.   FREE_OPEN_ARRAYS
  1004. }
  1005.  
  1006. static BOOLEAN yyIsEqual
  1007. # ifdef __STDC__
  1008. (BYTE yya[], LONGCARD O_3, BYTE yyb[], LONGCARD O_2)
  1009. # else
  1010. (yya, O_3, yyb, O_2)
  1011. BYTE yya[];
  1012. LONGCARD O_3;
  1013. BYTE yyb[];
  1014. LONGCARD O_2;
  1015. # endif
  1016. {
  1017.   INTEGER yyi;
  1018.   OPEN_ARRAY_LOCALS
  1019.  
  1020.   ALLOC_OPEN_ARRAYS(O_2 * sizeof(WORD) + O_3 * sizeof(WORD), 2)
  1021.   COPY_OPEN_ARRAY(yyb, O_2, WORD)
  1022.   COPY_OPEN_ARRAY(yya, O_3, WORD)
  1023.   {
  1024.     LONGINT B_1 = 0, B_2 = (INTEGER)(O_3 - 1);
  1025.  
  1026.     if (B_1 <= B_2)
  1027.       for (yyi = B_1;; yyi += 1) {
  1028.         if (yya[yyi] != yyb[yyi]) {
  1029.           FREE_OPEN_ARRAYS
  1030.           return FALSE;
  1031.         }
  1032.         if (yyi >= B_2) break;
  1033.       }
  1034.   }
  1035.   FREE_OPEN_ARRAYS
  1036.   return TRUE;
  1037. }
  1038.  
  1039. void C_MacroC
  1040. # ifdef __STDC__
  1041. (Tree_tTree t)
  1042. # else
  1043. (t)
  1044. Tree_tTree t;
  1045. # endif
  1046. {
  1047.   struct S_3 yyTempo;
  1048.  
  1049.   if (t == Tree_NoTree) {
  1050.     return;
  1051.   }
  1052.   if (t->U_1.V_1.Kind == Tree_Spec) {
  1053.     {
  1054.       register Tree_ySpec *W_21 = &t->U_1.V_26.Spec;
  1055.  
  1056.       C_MacroC(W_21->TreeNames);
  1057.       return;
  1058.     }
  1059.   }
  1060.   if (t->U_1.V_1.Kind == Tree_TreeName) {
  1061.     {
  1062.       register Tree_yTreeName *W_22 = &t->U_1.V_29.TreeName;
  1063.  
  1064.       IO_WriteS(Tree_f, (STRING)"# define begint", 15L);
  1065.       Tree_WI(W_22->Name);
  1066.       IO_WriteS(Tree_f, (STRING)"(a)    a = NULL;", 13L);
  1067.       IO_WriteNl(Tree_f);
  1068.       IO_WriteS(Tree_f, (STRING)"# define equalt", 15L);
  1069.       Tree_WI(W_22->Name);
  1070.       IO_WriteS(Tree_f, (STRING)"(a, b)    IsEqual", 14L);
  1071.       Tree_WI(W_22->Name);
  1072.       IO_WriteS(Tree_f, (STRING)" (a, b)", 7L);
  1073.       IO_WriteNl(Tree_f);
  1074.       C_MacroC(W_22->Next);
  1075.       return;
  1076.     }
  1077.   }
  1078. }
  1079.  
  1080. void C_DefC
  1081. # ifdef __STDC__
  1082. (Tree_tTree t)
  1083. # else
  1084. (t)
  1085. Tree_tTree t;
  1086. # endif
  1087. {
  1088.   struct S_4 yyTempo;
  1089.  
  1090.   if (t == Tree_NoTree) {
  1091.     return;
  1092.   }
  1093.   if (t->U_1.V_1.Kind == Tree_Spec) {
  1094.     {
  1095.       register Tree_ySpec *W_23 = &t->U_1.V_26.Spec;
  1096.  
  1097.       IO_WriteS(Tree_f, (STRING)"# ifndef yy", 11L);
  1098.       Tree_WI(W_23->TrafoName);
  1099.       IO_WriteNl(Tree_f);
  1100.       IO_WriteS(Tree_f, (STRING)"# define yy", 11L);
  1101.       Tree_WI(W_23->TrafoName);
  1102.       IO_WriteNl(Tree_f);
  1103.       IO_WriteNl(Tree_f);
  1104.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1105.       IO_WriteNl(Tree_f);
  1106.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    parameters", 36L);
  1107.       IO_WriteNl(Tree_f);
  1108.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1109.       IO_WriteNl(Tree_f);
  1110.       IO_WriteS(Tree_f, (STRING)"# define ARGS(parameters)    ()", 28L);
  1111.       IO_WriteNl(Tree_f);
  1112.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1113.       IO_WriteNl(Tree_f);
  1114.       IO_WriteNl(Tree_f);
  1115.       IO_WriteS(Tree_f, (STRING)"# ifndef bool", 13L);
  1116.       IO_WriteNl(Tree_f);
  1117.       IO_WriteS(Tree_f, (STRING)"# define bool char", 18L);
  1118.       IO_WriteNl(Tree_f);
  1119.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1120.       IO_WriteNl(Tree_f);
  1121.       IO_WriteNl(Tree_f);
  1122.       C_DefC(W_23->TreeNames);
  1123.       IO_WriteNl(Tree_f);
  1124.       WriteLine(W_23->Codes->U_1.V_12.Codes.ImportLine);
  1125.       Texts_WriteText(Tree_f, W_23->Codes->U_1.V_12.Codes.Import);
  1126.       WriteLine(W_23->Codes->U_1.V_12.Codes.ExportLine);
  1127.       Texts_WriteText(Tree_f, W_23->Codes->U_1.V_12.Codes.Export);
  1128.       IO_WriteNl(Tree_f);
  1129.       IO_WriteS(Tree_f, (STRING)"extern void (* ", 15L);
  1130.       Tree_WI(W_23->TrafoName);
  1131.       IO_WriteS(Tree_f, (STRING)"_Exit) ();", 10L);
  1132.       IO_WriteNl(Tree_f);
  1133.       IO_WriteNl(Tree_f);
  1134.       C_DefC(W_23->Public);
  1135.       IO_WriteNl(Tree_f);
  1136.       IO_WriteS(Tree_f, (STRING)"extern void Begin", 17L);
  1137.       Tree_WI(W_23->TrafoName);
  1138.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  1139.       IO_WriteNl(Tree_f);
  1140.       IO_WriteS(Tree_f, (STRING)"extern void Close", 17L);
  1141.       Tree_WI(W_23->TrafoName);
  1142.       IO_WriteS(Tree_f, (STRING)" ();", 4L);
  1143.       IO_WriteNl(Tree_f);
  1144.       IO_WriteNl(Tree_f);
  1145.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1146.       IO_WriteNl(Tree_f);
  1147.       return;
  1148.     }
  1149.   }
  1150.   if (t->U_1.V_1.Kind == Tree_TreeName) {
  1151.     {
  1152.       register Tree_yTreeName *W_24 = &t->U_1.V_29.TreeName;
  1153.  
  1154.       IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  1155.       Tree_WI(W_24->Name);
  1156.       IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  1157.       IO_WriteNl(Tree_f);
  1158.       C_DefC(W_24->Next);
  1159.       return;
  1160.     }
  1161.   }
  1162.   if (t->U_1.V_1.Kind == Tree_Name) {
  1163.     {
  1164.       register Tree_yName *W_25 = &t->U_1.V_25.Name;
  1165.  
  1166.       if (W_25->Object != Tree_NoTree) {
  1167.         ListCount = 0;
  1168.         IO_WriteS(Tree_f, (STRING)"extern ", 7L);
  1169.         if (W_25->Object->U_1.V_1.Kind == Tree_Procedure) {
  1170.           IO_WriteS(Tree_f, (STRING)"void", 4L);
  1171.         } else if (W_25->Object->U_1.V_1.Kind == Tree_Function) {
  1172.           C_DefC(W_25->Object->U_1.V_34.Function.ReturnForm->U_1.V_86.Formal.TypeDesc);
  1173.         } else if (W_25->Object->U_1.V_1.Kind == Tree_Predicate) {
  1174.           IO_WriteS(Tree_f, (STRING)"bool", 4L);
  1175.         }
  1176.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  1177.         Tree_WI(W_25->Name);
  1178.         IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  1179.         C_DefC(W_25->Object->U_1.V_32.Routine.InForm);
  1180.         C_DefC(W_25->Object->U_1.V_32.Routine.OutForm);
  1181.         IO_WriteS(Tree_f, (STRING)"));", 3L);
  1182.         IO_WriteNl(Tree_f);
  1183.       }
  1184.       C_DefC(W_25->Next);
  1185.       return;
  1186.     }
  1187.   }
  1188.   if (t->U_1.V_1.Kind == Tree_Formal) {
  1189.     {
  1190.       register Tree_yFormal *W_26 = &t->U_1.V_86.Formal;
  1191.  
  1192.       if (ListCount > 0) {
  1193.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  1194.       }
  1195.       C_DefC(W_26->TypeDesc);
  1196.       if (W_26->Path->U_1.V_92.Var.IsOutput) {
  1197.         IO_WriteS(Tree_f, (STRING)" *", 2L);
  1198.       }
  1199.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1200.       Tree_WI(W_26->Name);
  1201.       INC(ListCount);
  1202.       C_DefC(W_26->Next);
  1203.       return;
  1204.     }
  1205.   }
  1206.   if (t->U_1.V_1.Kind == Tree_NodeTypes) {
  1207.     {
  1208.       register Tree_yNodeTypes *W_27 = &t->U_1.V_89.NodeTypes;
  1209.  
  1210.       IO_WriteS(Tree_f, (STRING)"t", 1L);
  1211.       Tree_WI(W_27->TreeName->U_1.V_29.TreeName.Name);
  1212.       return;
  1213.     }
  1214.   }
  1215.   if (t->U_1.V_1.Kind == Tree_UserType) {
  1216.     {
  1217.       register Tree_yUserType *W_28 = &t->U_1.V_90.UserType;
  1218.  
  1219.       Tree_WI(W_28->Type);
  1220.       return;
  1221.     }
  1222.   }
  1223. }
  1224.  
  1225. static void Forward
  1226. # ifdef __STDC__
  1227. (Tree_tTree t)
  1228. # else
  1229. (t)
  1230. Tree_tTree t;
  1231. # endif
  1232. {
  1233.   struct S_5 yyTempo;
  1234.  
  1235.   if (t == Tree_NoTree) {
  1236.     return;
  1237.   }
  1238.   if (t->U_1.V_1.Kind == Tree_Procedure) {
  1239.     {
  1240.       register Tree_yProcedure *W_29 = &t->U_1.V_33.Procedure;
  1241.  
  1242.       ListCount = 0;
  1243.       if (!W_29->IsExtern) {
  1244.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1245.       }
  1246.       IO_WriteS(Tree_f, (STRING)"void ", 5L);
  1247.       Tree_WI(W_29->Name);
  1248.       IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  1249.       C_DefC(W_29->InForm);
  1250.       C_DefC(W_29->OutForm);
  1251.       IO_WriteS(Tree_f, (STRING)"));", 3L);
  1252.       IO_WriteNl(Tree_f);
  1253.       Forward(W_29->Next);
  1254.       return;
  1255.     }
  1256.   }
  1257.   if (t->U_1.V_1.Kind == Tree_Function) {
  1258.     {
  1259.       register Tree_yFunction *W_30 = &t->U_1.V_34.Function;
  1260.  
  1261.       ListCount = 0;
  1262.       if (!W_30->IsExtern) {
  1263.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1264.       }
  1265.       C_DefC(W_30->ReturnForm->U_1.V_86.Formal.TypeDesc);
  1266.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1267.       Tree_WI(W_30->Name);
  1268.       IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  1269.       C_DefC(W_30->InForm);
  1270.       C_DefC(W_30->OutForm);
  1271.       IO_WriteS(Tree_f, (STRING)"));", 3L);
  1272.       IO_WriteNl(Tree_f);
  1273.       Forward(W_30->Next);
  1274.       return;
  1275.     }
  1276.   }
  1277.   if (t->U_1.V_1.Kind == Tree_Predicate) {
  1278.     {
  1279.       register Tree_yPredicate *W_31 = &t->U_1.V_35.Predicate;
  1280.  
  1281.       ListCount = 0;
  1282.       if (!W_31->IsExtern) {
  1283.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1284.       }
  1285.       IO_WriteS(Tree_f, (STRING)"bool ", 5L);
  1286.       Tree_WI(W_31->Name);
  1287.       IO_WriteS(Tree_f, (STRING)" ARGS((", 7L);
  1288.       C_DefC(W_31->InForm);
  1289.       C_DefC(W_31->OutForm);
  1290.       IO_WriteS(Tree_f, (STRING)"));", 3L);
  1291.       IO_WriteNl(Tree_f);
  1292.       Forward(W_31->Next);
  1293.       return;
  1294.     }
  1295.   }
  1296. }
  1297.  
  1298. static void ProcHead1
  1299. # ifdef __STDC__
  1300. (Tree_tTree t)
  1301. # else
  1302. (t)
  1303. Tree_tTree t;
  1304. # endif
  1305. {
  1306.   struct S_6 yyTempo;
  1307.  
  1308.   if (t == Tree_NoTree) {
  1309.     return;
  1310.   }
  1311.   if (t->U_1.V_1.Kind == Tree_Formal) {
  1312.     {
  1313.       register Tree_yFormal *W_32 = &t->U_1.V_86.Formal;
  1314.  
  1315.       if (ListCount > 0) {
  1316.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  1317.       }
  1318.       Tree_WI(W_32->Name);
  1319.       INC(ListCount);
  1320.       ProcHead1(W_32->Next);
  1321.       return;
  1322.     }
  1323.   }
  1324. }
  1325.  
  1326. static void ProcHead2
  1327. # ifdef __STDC__
  1328. (Tree_tTree t)
  1329. # else
  1330. (t)
  1331. Tree_tTree t;
  1332. # endif
  1333. {
  1334.   struct S_7 yyTempo;
  1335.  
  1336.   if (t == Tree_NoTree) {
  1337.     return;
  1338.   }
  1339.   if (t->U_1.V_1.Kind == Tree_Formal) {
  1340.     {
  1341.       register Tree_yFormal *W_33 = &t->U_1.V_86.Formal;
  1342.  
  1343.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1344.       if (W_33->TypeDesc->U_1.V_1.Kind == Tree_NodeTypes && W_33->Path->U_1.V_92.Var.IsRegister) {
  1345.         IO_WriteS(Tree_f, (STRING)"register ", 9L);
  1346.       }
  1347.       C_ImplC(W_33->TypeDesc);
  1348.       if (W_33->Path->U_1.V_92.Var.IsOutput) {
  1349.         IO_WriteS(Tree_f, (STRING)" *", 2L);
  1350.       }
  1351.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1352.       Tree_WI(W_33->Name);
  1353.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1354.       IO_WriteNl(Tree_f);
  1355.       ProcHead2(W_33->Next);
  1356.       return;
  1357.     }
  1358.   }
  1359. }
  1360.  
  1361. static void ProcHead3
  1362. # ifdef __STDC__
  1363. (Tree_tTree t)
  1364. # else
  1365. (t)
  1366. Tree_tTree t;
  1367. # endif
  1368. {
  1369.   struct S_8 yyTempo;
  1370.  
  1371.   if (t == Tree_NoTree) {
  1372.     return;
  1373.   }
  1374.   if (t->U_1.V_1.Kind == Tree_Formal) {
  1375.     {
  1376.       register Tree_yFormal *W_34 = &t->U_1.V_86.Formal;
  1377.  
  1378.       if (ListCount > 0) {
  1379.         IO_WriteS(Tree_f, (STRING)", ", 2L);
  1380.       }
  1381.       if (W_34->TypeDesc->U_1.V_1.Kind == Tree_NodeTypes && W_34->Path->U_1.V_92.Var.IsRegister) {
  1382.         IO_WriteS(Tree_f, (STRING)"register ", 9L);
  1383.       }
  1384.       C_ImplC(W_34->TypeDesc);
  1385.       if (W_34->Path->U_1.V_92.Var.IsOutput) {
  1386.         IO_WriteS(Tree_f, (STRING)" *", 2L);
  1387.       }
  1388.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1389.       Tree_WI(W_34->Name);
  1390.       INC(ListCount);
  1391.       ProcHead3(W_34->Next);
  1392.       return;
  1393.     }
  1394.   }
  1395. }
  1396.  
  1397. void C_ImplC
  1398. # ifdef __STDC__
  1399. (Tree_tTree t)
  1400. # else
  1401. (t)
  1402. Tree_tTree t;
  1403. # endif
  1404. {
  1405.   struct S_9 yyTempo;
  1406.  
  1407.   if (t == Tree_NoTree) {
  1408.     return;
  1409.   }
  1410.   switch (t->U_1.V_1.Kind) {
  1411.   case Tree_Spec:;
  1412.     {
  1413.       register Tree_ySpec *W_35 = &t->U_1.V_26.Spec;
  1414.  
  1415.       IO_WriteS(Tree_f, (STRING)"# include \"", 11L);
  1416.       Tree_WI(W_35->TrafoName);
  1417.       IO_WriteS(Tree_f, (STRING)".h\"", 3L);
  1418.       IO_WriteNl(Tree_f);
  1419.       IO_WriteS(Tree_f, (STRING)"# ifdef __cplusplus", 19L);
  1420.       IO_WriteNl(Tree_f);
  1421.       IO_WriteS(Tree_f, (STRING)"extern \"C\" {", 12L);
  1422.       IO_WriteNl(Tree_f);
  1423.       IO_WriteS(Tree_f, (STRING)"# include \"System.h\"", 20L);
  1424.       IO_WriteNl(Tree_f);
  1425.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1426.       IO_WriteNl(Tree_f);
  1427.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1428.       IO_WriteNl(Tree_f);
  1429.       IO_WriteS(Tree_f, (STRING)"# include \"System.h\"", 20L);
  1430.       IO_WriteNl(Tree_f);
  1431.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1432.       IO_WriteNl(Tree_f);
  1433.       IO_WriteS(Tree_f, (STRING)"# include <stdio.h>", 19L);
  1434.       IO_WriteNl(Tree_f);
  1435.       C_DefC(W_35->TreeNames);
  1436.       IO_WriteNl(Tree_f);
  1437.       if (!Sets_IsElement(ORD('m'), &Tree_Options)) {
  1438.         IO_WriteS(Tree_f, (STRING)"# define yyInline", 17L);
  1439.         IO_WriteNl(Tree_f);
  1440.       }
  1441.       IO_WriteS(Tree_f, (STRING)"# ifndef NULL", 13L);
  1442.       IO_WriteNl(Tree_f);
  1443.       IO_WriteS(Tree_f, (STRING)"# define NULL 0L", 16L);
  1444.       IO_WriteNl(Tree_f);
  1445.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1446.       IO_WriteNl(Tree_f);
  1447.       IO_WriteS(Tree_f, (STRING)"# ifndef false", 14L);
  1448.       IO_WriteNl(Tree_f);
  1449.       IO_WriteS(Tree_f, (STRING)"# define false 0", 16L);
  1450.       IO_WriteNl(Tree_f);
  1451.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1452.       IO_WriteNl(Tree_f);
  1453.       IO_WriteS(Tree_f, (STRING)"# ifndef true", 13L);
  1454.       IO_WriteNl(Tree_f);
  1455.       IO_WriteS(Tree_f, (STRING)"# define true 1", 15L);
  1456.       IO_WriteNl(Tree_f);
  1457.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1458.       IO_WriteNl(Tree_f);
  1459.       IO_WriteNl(Tree_f);
  1460.       IO_WriteS(Tree_f, (STRING)"# ifdef yyInline", 16L);
  1461.       IO_WriteNl(Tree_f);
  1462.       IO_WriteS(Tree_f, (STRING)"# define yyALLOC(tree, free, max, alloc, nodesize, make, ptr, kind) \\", 69L);
  1463.       IO_WriteNl(Tree_f);
  1464.       IO_WriteS(Tree_f, (STRING)"  if ((ptr = (tree) free) >= (tree) max) ptr = alloc (); \\", 58L);
  1465.       IO_WriteNl(Tree_f);
  1466.       IO_WriteS(Tree_f, (STRING)"  free += nodesize [kind]; \\", 28L);
  1467.       IO_WriteNl(Tree_f);
  1468.       IO_WriteS(Tree_f, (STRING)"  ptr->yyHead.yyMark = 0; \\", 27L);
  1469.       IO_WriteNl(Tree_f);
  1470.       IO_WriteS(Tree_f, (STRING)"  ptr->Kind = kind;", 19L);
  1471.       IO_WriteNl(Tree_f);
  1472.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1473.       IO_WriteNl(Tree_f);
  1474.       IO_WriteS(Tree_f, (STRING)"# define yyALLOC(tree, free, max, alloc, nodesize, make, ptr, kind) ptr = make (kind);", 86L);
  1475.       IO_WriteNl(Tree_f);
  1476.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1477.       IO_WriteNl(Tree_f);
  1478.       IO_WriteNl(Tree_f);
  1479.       IO_WriteS(Tree_f, (STRING)"# define yyWrite(s) (void) fputs (s, yyf)", 41L);
  1480.       IO_WriteNl(Tree_f);
  1481.       IO_WriteS(Tree_f, (STRING)"# define yyWriteNl (void) fputc ('\\n', yyf)", 43L);
  1482.       IO_WriteNl(Tree_f);
  1483.       IO_WriteNl(Tree_f);
  1484.       WriteLine(W_35->Codes->U_1.V_12.Codes.GlobalLine);
  1485.       Texts_WriteText(Tree_f, W_35->Codes->U_1.V_12.Codes.Global);
  1486.       IO_WriteS(Tree_f, (STRING)"# include \"yy", 13L);
  1487.       Tree_WI(W_35->TrafoName);
  1488.       IO_WriteS(Tree_f, (STRING)".w\"", 3L);
  1489.       IO_WriteNl(Tree_f);
  1490.       IO_WriteNl(Tree_f);
  1491.       IO_WriteS(Tree_f, (STRING)"static void yyExit () { Exit (1); }", 35L);
  1492.       IO_WriteNl(Tree_f);
  1493.       IO_WriteNl(Tree_f);
  1494.       IO_WriteS(Tree_f, (STRING)"void (* ", 8L);
  1495.       Tree_WI(W_35->TrafoName);
  1496.       IO_WriteS(Tree_f, (STRING)"_Exit) () = yyExit;", 19L);
  1497.       IO_WriteNl(Tree_f);
  1498.       IO_WriteNl(Tree_f);
  1499.       IO_WriteS(Tree_f, (STRING)"static FILE * yyf = stdout;", 27L);
  1500.       IO_WriteNl(Tree_f);
  1501.       IO_WriteNl(Tree_f);
  1502.       IO_WriteS(Tree_f, (STRING)"static void yyAbort", 19L);
  1503.       IO_WriteNl(Tree_f);
  1504.       IO_WriteS(Tree_f, (STRING)"# ifdef __cplusplus", 19L);
  1505.       IO_WriteNl(Tree_f);
  1506.       IO_WriteS(Tree_f, (STRING)" (char * yyFunction)", 20L);
  1507.       IO_WriteNl(Tree_f);
  1508.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1509.       IO_WriteNl(Tree_f);
  1510.       IO_WriteS(Tree_f, (STRING)" (yyFunction) char * yyFunction;", 32L);
  1511.       IO_WriteNl(Tree_f);
  1512.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1513.       IO_WriteNl(Tree_f);
  1514.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1515.       IO_WriteNl(Tree_f);
  1516.       IO_WriteS(Tree_f, (STRING)" (void) fprintf (stderr, \"Error: module ", 40L);
  1517.       Tree_WI(W_35->TrafoName);
  1518.       IO_WriteS(Tree_f, (STRING)", routine %s failed\\n\", yyFunction);", 36L);
  1519.       IO_WriteNl(Tree_f);
  1520.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1521.       Tree_WI(W_35->TrafoName);
  1522.       IO_WriteS(Tree_f, (STRING)"_Exit ();", 9L);
  1523.       IO_WriteNl(Tree_f);
  1524.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1525.       IO_WriteNl(Tree_f);
  1526.       IO_WriteNl(Tree_f);
  1527.       Forward(W_35->Routines);
  1528.       IO_WriteNl(Tree_f);
  1529.       C_ImplC(W_35->Routines);
  1530.       IO_WriteS(Tree_f, (STRING)"void Begin", 10L);
  1531.       Tree_WI(W_35->TrafoName);
  1532.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  1533.       IO_WriteNl(Tree_f);
  1534.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1535.       IO_WriteNl(Tree_f);
  1536.       WriteLine(W_35->Codes->U_1.V_12.Codes.BeginLine);
  1537.       Texts_WriteText(Tree_f, W_35->Codes->U_1.V_12.Codes.Begin);
  1538.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1539.       IO_WriteNl(Tree_f);
  1540.       IO_WriteNl(Tree_f);
  1541.       IO_WriteS(Tree_f, (STRING)"void Close", 10L);
  1542.       Tree_WI(W_35->TrafoName);
  1543.       IO_WriteS(Tree_f, (STRING)" ()", 3L);
  1544.       IO_WriteNl(Tree_f);
  1545.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1546.       IO_WriteNl(Tree_f);
  1547.       WriteLine(W_35->Codes->U_1.V_12.Codes.CloseLine);
  1548.       Texts_WriteText(Tree_f, W_35->Codes->U_1.V_12.Codes.Close);
  1549.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1550.       IO_WriteNl(Tree_f);
  1551.       return;
  1552.     }
  1553.     break;
  1554.   case Tree_Procedure:;
  1555.     {
  1556.       register Tree_yProcedure *W_36 = &t->U_1.V_33.Procedure;
  1557.  
  1558.       if (!W_36->IsExtern) {
  1559.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1560.       }
  1561.       IO_WriteS(Tree_f, (STRING)"void ", 5L);
  1562.       Tree_WI(W_36->Name);
  1563.       IO_WriteNl(Tree_f);
  1564.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1565.       IO_WriteNl(Tree_f);
  1566.       ListCount = 0;
  1567.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1568.       ProcHead3(W_36->InForm);
  1569.       ProcHead3(W_36->OutForm);
  1570.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1571.       IO_WriteNl(Tree_f);
  1572.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1573.       IO_WriteNl(Tree_f);
  1574.       ListCount = 0;
  1575.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1576.       ProcHead1(W_36->InForm);
  1577.       ProcHead1(W_36->OutForm);
  1578.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1579.       IO_WriteNl(Tree_f);
  1580.       ProcHead2(W_36->InForm);
  1581.       ProcHead2(W_36->OutForm);
  1582.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1583.       IO_WriteNl(Tree_f);
  1584.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1585.       IO_WriteNl(Tree_f);
  1586.       WriteLine(W_36->LocalLine);
  1587.       Texts_WriteText(Tree_f, W_36->Local);
  1588.       RoutineKind = kProcedure;
  1589.       InFormals = W_36->InForm;
  1590.       OutFormals = W_36->OutForm;
  1591.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  1592.         Tg1(W_36->InForm);
  1593.       }
  1594.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  1595.         C_ImplC(W_36->Rules);
  1596.         if (Sets_IsElement(ORD('f'), &Tree_Options)) {
  1597.           IO_WriteS(Tree_f, (STRING)" yyAbort (\"", 11L);
  1598.           Tree_WI(W_36->Name);
  1599.           IO_WriteS(Tree_f, (STRING)"\");", 3L);
  1600.           IO_WriteNl(Tree_f);
  1601.         }
  1602.       } else {
  1603.         TemposDone = FALSE;
  1604.         CommonTestElim(W_36->Decisions);
  1605.         if (Sets_IsElement(ORD('f'), &Tree_Options) && !Optimize_NeedsNoFinale(W_36->Decisions)) {
  1606.           IO_WriteS(Tree_f, (STRING)" yyAbort (\"", 11L);
  1607.           Tree_WI(W_36->Name);
  1608.           IO_WriteS(Tree_f, (STRING)"\");", 3L);
  1609.           IO_WriteNl(Tree_f);
  1610.         }
  1611.       }
  1612.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1613.       IO_WriteNl(Tree_f);
  1614.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1615.       IO_WriteNl(Tree_f);
  1616.       IO_WriteNl(Tree_f);
  1617.       C_ImplC(W_36->Next);
  1618.       return;
  1619.     }
  1620.     break;
  1621.   case Tree_Function:;
  1622.     {
  1623.       register Tree_yFunction *W_37 = &t->U_1.V_34.Function;
  1624.  
  1625.       if (!W_37->IsExtern) {
  1626.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1627.       }
  1628.       C_DefC(W_37->ReturnForm->U_1.V_86.Formal.TypeDesc);
  1629.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  1630.       Tree_WI(W_37->Name);
  1631.       IO_WriteNl(Tree_f);
  1632.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1633.       IO_WriteNl(Tree_f);
  1634.       ListCount = 0;
  1635.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1636.       ProcHead3(W_37->InForm);
  1637.       ProcHead3(W_37->OutForm);
  1638.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1639.       IO_WriteNl(Tree_f);
  1640.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1641.       IO_WriteNl(Tree_f);
  1642.       ListCount = 0;
  1643.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1644.       ProcHead1(W_37->InForm);
  1645.       ProcHead1(W_37->OutForm);
  1646.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1647.       IO_WriteNl(Tree_f);
  1648.       ProcHead2(W_37->InForm);
  1649.       ProcHead2(W_37->OutForm);
  1650.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1651.       IO_WriteNl(Tree_f);
  1652.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1653.       IO_WriteNl(Tree_f);
  1654.       WriteLine(W_37->LocalLine);
  1655.       Texts_WriteText(Tree_f, W_37->Local);
  1656.       RoutineKind = kFunction;
  1657.       InFormals = W_37->InForm;
  1658.       OutFormals = W_37->OutForm;
  1659.       ReturnFormals = W_37->ReturnForm;
  1660.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  1661.         C_ImplC(W_37->Rules);
  1662.         IO_WriteS(Tree_f, (STRING)" yyAbort (\"", 11L);
  1663.         Tree_WI(W_37->Name);
  1664.         IO_WriteS(Tree_f, (STRING)"\");", 3L);
  1665.         IO_WriteNl(Tree_f);
  1666.       } else {
  1667.         TemposDone = FALSE;
  1668.         CommonTestElim(W_37->Decisions);
  1669.         if (!Optimize_NeedsNoFinale(W_37->Decisions)) {
  1670.           IO_WriteS(Tree_f, (STRING)" yyAbort (\"", 11L);
  1671.           Tree_WI(W_37->Name);
  1672.           IO_WriteS(Tree_f, (STRING)"\");", 3L);
  1673.           IO_WriteNl(Tree_f);
  1674.         }
  1675.       }
  1676.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1677.       IO_WriteNl(Tree_f);
  1678.       IO_WriteNl(Tree_f);
  1679.       C_ImplC(W_37->Next);
  1680.       return;
  1681.     }
  1682.     break;
  1683.   case Tree_Predicate:;
  1684.     {
  1685.       register Tree_yPredicate *W_38 = &t->U_1.V_35.Predicate;
  1686.  
  1687.       if (!W_38->IsExtern) {
  1688.         IO_WriteS(Tree_f, (STRING)"static ", 7L);
  1689.       }
  1690.       IO_WriteS(Tree_f, (STRING)"bool ", 5L);
  1691.       Tree_WI(W_38->Name);
  1692.       IO_WriteNl(Tree_f);
  1693.       IO_WriteS(Tree_f, (STRING)"# if defined __STDC__ | defined __cplusplus", 43L);
  1694.       IO_WriteNl(Tree_f);
  1695.       ListCount = 0;
  1696.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1697.       ProcHead3(W_38->InForm);
  1698.       ProcHead3(W_38->OutForm);
  1699.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1700.       IO_WriteNl(Tree_f);
  1701.       IO_WriteS(Tree_f, (STRING)"# else", 6L);
  1702.       IO_WriteNl(Tree_f);
  1703.       ListCount = 0;
  1704.       IO_WriteS(Tree_f, (STRING)"(", 1L);
  1705.       ProcHead1(W_38->InForm);
  1706.       ProcHead1(W_38->OutForm);
  1707.       IO_WriteS(Tree_f, (STRING)")", 1L);
  1708.       IO_WriteNl(Tree_f);
  1709.       ProcHead2(W_38->InForm);
  1710.       ProcHead2(W_38->OutForm);
  1711.       IO_WriteS(Tree_f, (STRING)"# endif", 7L);
  1712.       IO_WriteNl(Tree_f);
  1713.       IO_WriteS(Tree_f, (STRING)"{", 1L);
  1714.       IO_WriteNl(Tree_f);
  1715.       WriteLine(W_38->LocalLine);
  1716.       Texts_WriteText(Tree_f, W_38->Local);
  1717.       RoutineKind = kPredicate;
  1718.       InFormals = W_38->InForm;
  1719.       OutFormals = W_38->OutForm;
  1720.       if (Sets_IsElement(ORD('n'), &Tree_Options)) {
  1721.         Tg1(W_38->InForm);
  1722.       }
  1723.       if (Sets_IsElement(ORD('b'), &Tree_Options)) {
  1724.         C_ImplC(W_38->Rules);
  1725.         IO_WriteS(Tree_f, (STRING)"  return false;", 15L);
  1726.         IO_WriteNl(Tree_f);
  1727.       } else {
  1728.         TemposDone = FALSE;
  1729.         CommonTestElim(W_38->Decisions);
  1730.         if (!Optimize_NeedsNoFinale(W_38->Decisions)) {
  1731.           IO_WriteS(Tree_f, (STRING)"  return false;", 15L);
  1732.           IO_WriteNl(Tree_f);
  1733.         }
  1734.       }
  1735.       IO_WriteS(Tree_f, (STRING)"}", 1L);
  1736.       IO_WriteNl(Tree_f);
  1737.       IO_WriteNl(Tree_f);
  1738.       C_ImplC(W_38->Next);
  1739.       return;
  1740.     }
  1741.     break;
  1742.   case Tree_Rule:;
  1743.     {
  1744.       register Tree_yRule *W_39 = &t->U_1.V_42.Rule;
  1745.  
  1746.       WriteLine(W_39->Line);
  1747.       if (W_39->HasTempos) {
  1748.         IO_WriteS(Tree_f, (STRING)" {", 2L);
  1749.         IO_WriteNl(Tree_f);
  1750.       }
  1751.       RuleCount = W_39->Index;
  1752.       WithCount = 0;
  1753.       Decls = W_39->VarDecls;
  1754.       Declare(W_39->Patterns);
  1755.       Declare(W_39->Exprs);
  1756.       Declare(W_39->Statements);
  1757.       Match(W_39->Patterns, InFormals);
  1758.       if (W_39->Statements->U_1.V_1.Kind != Tree_NoStatement) {
  1759.         IO_WriteS(Tree_f, (STRING)"  {", 3L);
  1760.         IO_WriteNl(Tree_f);
  1761.         C_ImplC(W_39->Statements);
  1762.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1763.         IO_WriteNl(Tree_f);
  1764.       }
  1765.       if (!W_39->HasRejectOrFail) {
  1766.         AssignFormals(W_39->Exprs, OutFormals);
  1767.         switch (RoutineKind) {
  1768.         case kProcedure:;
  1769.           IO_WriteS(Tree_f, (STRING)"   return;", 10L);
  1770.           IO_WriteNl(Tree_f);
  1771.           break;
  1772.         case kFunction:;
  1773.           if (W_39->HasPatterns && W_39->Expr->U_1.V_1.Kind != Tree_Compose && t->U_1.V_1.Kind != Tree_DontCare1) {
  1774.             IO_WriteS(Tree_f, (STRING)"  {register ", 12L);
  1775.             C_DefC(ReturnFormals->U_1.V_86.Formal.TypeDesc);
  1776.             IO_WriteS(Tree_f, (STRING)" ", 1L);
  1777.             Tree_WI(W_39->Tempo);
  1778.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1779.             IO_WriteNl(Tree_f);
  1780.             Declare(W_39->Expr);
  1781.             AssignTempo(W_39->Expr);
  1782.             IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1783.             Tree_WI(W_39->Tempo);
  1784.             IO_WriteS(Tree_f, (STRING)" = ", 3L);
  1785.             Expression(W_39->Expr);
  1786.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1787.             IO_WriteNl(Tree_f);
  1788.             MatchExpr(W_39->Expr);
  1789.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  1790.             Tree_WI(W_39->Tempo);
  1791.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1792.             IO_WriteNl(Tree_f);
  1793.             IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1794.             IO_WriteNl(Tree_f);
  1795.           } else if (W_39->HasTempos) {
  1796.             IO_WriteS(Tree_f, (STRING)"  {", 3L);
  1797.             IO_WriteNl(Tree_f);
  1798.             Declare(W_39->Expr);
  1799.             AssignTempo(W_39->Expr);
  1800.             MatchExpr(W_39->Expr);
  1801.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  1802.             Expression(W_39->Expr);
  1803.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1804.             IO_WriteNl(Tree_f);
  1805.             IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1806.             IO_WriteNl(Tree_f);
  1807.           } else {
  1808.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  1809.             Expression(W_39->Expr);
  1810.             IO_WriteS(Tree_f, (STRING)";", 1L);
  1811.             IO_WriteNl(Tree_f);
  1812.           }
  1813.           break;
  1814.         case kPredicate:;
  1815.           IO_WriteS(Tree_f, (STRING)"   return true;", 15L);
  1816.           IO_WriteNl(Tree_f);
  1817.           break;
  1818.         }
  1819.       }
  1820.       if (W_39->HasTempos) {
  1821.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  1822.         IO_WriteNl(Tree_f);
  1823.       }
  1824.       IO_WriteS(Tree_f, (STRING)"yyL", 3L);
  1825.       Tree_WN(RuleCount);
  1826.       IO_WriteS(Tree_f, (STRING)":;", 2L);
  1827.       IO_WriteNl(Tree_f);
  1828.       IO_WriteNl(Tree_f);
  1829.       C_ImplC(W_39->Next);
  1830.       return;
  1831.     }
  1832.     break;
  1833.   case Tree_ProcCall:;
  1834.     {
  1835.       register Tree_yProcCall *W_40 = &t->U_1.V_76.ProcCall;
  1836.  
  1837.       WriteLine(W_40->Pos);
  1838.       AssignTempo(W_40->Call);
  1839.       IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1840.       Expression(W_40->Call);
  1841.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1842.       IO_WriteNl(Tree_f);
  1843.       MatchExpr(W_40->Call);
  1844.       C_ImplC(W_40->Next);
  1845.       return;
  1846.     }
  1847.     break;
  1848.   case Tree_Condition:;
  1849.     {
  1850.       register Tree_yCondition *W_41 = &t->U_1.V_77.Condition;
  1851.  
  1852.       WriteLine(W_41->Pos);
  1853.       AssignTempo(W_41->Expr);
  1854.       IO_WriteS(Tree_f, (STRING)"   if (! (", 10L);
  1855.       Expression(W_41->Expr);
  1856.       IO_WriteS(Tree_f, (STRING)")) goto yyL", 11L);
  1857.       Tree_WN(RuleCount);
  1858.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1859.       IO_WriteNl(Tree_f);
  1860.       MatchExpr(W_41->Expr);
  1861.       if (W_41->Next->U_1.V_1.Kind != Tree_NoStatement) {
  1862.         IO_WriteS(Tree_f, (STRING)"  {", 3L);
  1863.         IO_WriteNl(Tree_f);
  1864.         C_ImplC(W_41->Next);
  1865.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  1866.         IO_WriteNl(Tree_f);
  1867.       }
  1868.       return;
  1869.     }
  1870.     break;
  1871.   case Tree_Assignment:;
  1872.     {
  1873.       register Tree_yAssignment *W_42 = &t->U_1.V_78.Assignment;
  1874.  
  1875.       WriteLine(W_42->Pos);
  1876.       AssignTempo(W_42->Adr);
  1877.       AssignTempo(W_42->Expr);
  1878.       if (W_42->Object != Tree_NoTree) {
  1879.         IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1880.         C_ImplC(W_42->Object->U_1.V_86.Formal.Path);
  1881.       } else {
  1882.         IO_WriteS(Tree_f, (STRING)"   ", 3L);
  1883.         Expression(W_42->Adr);
  1884.       }
  1885.       IO_WriteS(Tree_f, (STRING)" = ", 3L);
  1886.       Expression(W_42->Expr);
  1887.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1888.       IO_WriteNl(Tree_f);
  1889.       MatchExpr(W_42->Adr);
  1890.       MatchExpr(W_42->Expr);
  1891.       C_ImplC(W_42->Next);
  1892.       return;
  1893.     }
  1894.     break;
  1895.   case Tree_Reject:;
  1896.     {
  1897.       register Tree_yReject *W_43 = &t->U_1.V_79.Reject;
  1898.  
  1899.       WriteLine(W_43->Pos);
  1900.       IO_WriteS(Tree_f, (STRING)"   goto yyL", 11L);
  1901.       Tree_WN(RuleCount);
  1902.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1903.       IO_WriteNl(Tree_f);
  1904.       return;
  1905.     }
  1906.     break;
  1907.   case Tree_Fail:;
  1908.     {
  1909.       register Tree_yFail *W_44 = &t->U_1.V_80.Fail;
  1910.  
  1911.       WriteLine(W_44->Pos);
  1912.       IO_WriteS(Tree_f, (STRING)"   return", 9L);
  1913.       if (RoutineKind == kPredicate) {
  1914.         IO_WriteS(Tree_f, (STRING)" false", 6L);
  1915.       }
  1916.       IO_WriteS(Tree_f, (STRING)";", 1L);
  1917.       IO_WriteNl(Tree_f);
  1918.       return;
  1919.     }
  1920.     break;
  1921.   case Tree_TargetStmt:;
  1922.     {
  1923.       register Tree_yTargetStmt *W_45 = &t->U_1.V_81.TargetStmt;
  1924.  
  1925.       WriteLine(W_45->Pos);
  1926.       C_ImplC(W_45->Stmt);
  1927.       IO_WriteNl(Tree_f);
  1928.       C_ImplC(W_45->Next);
  1929.       return;
  1930.     }
  1931.     break;
  1932.   case Tree_Nl:;
  1933.     {
  1934.       register Tree_yNl *W_46 = &t->U_1.V_82.Nl;
  1935.  
  1936.       WriteLine(W_46->Pos);
  1937.       IO_WriteS(Tree_f, (STRING)"   yyWriteNl;", 13L);
  1938.       IO_WriteNl(Tree_f);
  1939.       C_ImplC(W_46->Next);
  1940.       return;
  1941.     }
  1942.     break;
  1943.   case Tree_WriteStr:;
  1944.     {
  1945.       register Tree_yWriteStr *W_47 = &t->U_1.V_83.WriteStr;
  1946.  
  1947.       WriteLine(W_47->Pos);
  1948.       IO_WriteS(Tree_f, (STRING)"   yyWrite (", 12L);
  1949.       StringMem_WriteString(Tree_f, W_47->String);
  1950.       IO_WriteS(Tree_f, (STRING)");", 2L);
  1951.       IO_WriteNl(Tree_f);
  1952.       C_ImplC(W_47->Next);
  1953.       return;
  1954.     }
  1955.     break;
  1956.   case Tree_Ident:;
  1957.     {
  1958.       register struct S_10 *W_48 = &yyTempo.U_1.V_1.yyR14;
  1959.  
  1960.       {
  1961.         register Tree_yIdent *W_49 = &t->U_1.V_16.Ident;
  1962.  
  1963.         W_48->Var = Semantics_IdentifyVar(Decls, W_49->Attribute);
  1964.         if (W_48->Var != Tree_NoTree) {
  1965.           C_ImplC(W_48->Var->U_1.V_86.Formal.Path);
  1966.         } else {
  1967.           Tree_WI(W_49->Attribute);
  1968.         }
  1969.         C_ImplC(W_49->Next);
  1970.         return;
  1971.       }
  1972.     }
  1973.     break;
  1974.   case Tree_Any:;
  1975.     {
  1976.       register Tree_yAny *W_50 = &t->U_1.V_18.Any;
  1977.  
  1978.       StringMem_WriteString(Tree_f, W_50->Code);
  1979.       C_ImplC(W_50->Next);
  1980.       return;
  1981.     }
  1982.     break;
  1983.   case Tree_Anys:;
  1984.     {
  1985.       register Tree_yAnys *W_51 = &t->U_1.V_19.Anys;
  1986.  
  1987.       C_ImplC(W_51->Layouts);
  1988.       C_ImplC(W_51->Next);
  1989.       return;
  1990.     }
  1991.     break;
  1992.   case Tree_LayoutAny:;
  1993.     {
  1994.       register Tree_yLayoutAny *W_52 = &t->U_1.V_22.LayoutAny;
  1995.  
  1996.       StringMem_WriteString(Tree_f, W_52->Code);
  1997.       C_ImplC(W_52->Next);
  1998.       return;
  1999.     }
  2000.     break;
  2001.   case Tree_Designator:;
  2002.     {
  2003.       register Tree_yDesignator *W_53 = &t->U_1.V_15.Designator;
  2004.  
  2005.       C_ImplC(W_53->Object->U_1.V_86.Formal.Path);
  2006.       IO_WriteS(Tree_f, (STRING)"->", 2L);
  2007.       Tree_WI(W_53->Type);
  2008.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2009.       Tree_WI(W_53->Attribute);
  2010.       C_ImplC(W_53->Next);
  2011.       return;
  2012.     }
  2013.     break;
  2014.   case Tree_Field:;
  2015.     {
  2016.       register Tree_yField *W_54 = &t->U_1.V_94.Field;
  2017.  
  2018.       C_ImplC(W_54->Next);
  2019.       IO_WriteS(Tree_f, (STRING)".", 1L);
  2020.       Tree_WI(W_54->Name);
  2021.       return;
  2022.     }
  2023.     break;
  2024.   case Tree_ConsType:;
  2025.     {
  2026.       register Tree_yConsType *W_55 = &t->U_1.V_93.ConsType;
  2027.  
  2028.       C_ImplC(W_55->Next);
  2029.       IO_WriteS(Tree_f, (STRING)"->", 2L);
  2030.       Tree_WI(W_55->Name);
  2031.       return;
  2032.     }
  2033.     break;
  2034.   case Tree_Var:;
  2035.     {
  2036.       register Tree_yVar *W_56 = &t->U_1.V_92.Var;
  2037.  
  2038.       if (W_56->IsOutput) {
  2039.         IO_WriteS(Tree_f, (STRING)"(* ", 3L);
  2040.         Tree_WI(W_56->Name);
  2041.         IO_WriteS(Tree_f, (STRING)")", 1L);
  2042.       } else {
  2043.         Tree_WI(W_56->Name);
  2044.       }
  2045.       return;
  2046.     }
  2047.     break;
  2048.   case Tree_NodeTypes:;
  2049.     {
  2050.       register Tree_yNodeTypes *W_57 = &t->U_1.V_89.NodeTypes;
  2051.  
  2052.       IO_WriteS(Tree_f, (STRING)"t", 1L);
  2053.       Tree_WI(W_57->TreeName->U_1.V_29.TreeName.Name);
  2054.       return;
  2055.     }
  2056.     break;
  2057.   case Tree_UserType:;
  2058.     {
  2059.       register Tree_yUserType *W_58 = &t->U_1.V_90.UserType;
  2060.  
  2061.       if (!Sets_IsElement((LONGCARD)W_58->Type, &Semantics_UserTypes)) {
  2062.         IO_WriteS(Tree_f, (STRING)"register ", 9L);
  2063.       }
  2064.       Tree_WI(W_58->Type);
  2065.       return;
  2066.     }
  2067.     break;
  2068.   default :
  2069.     break;
  2070.   }
  2071. }
  2072.  
  2073. static void Declare
  2074. # ifdef __STDC__
  2075. (Tree_tTree t)
  2076. # else
  2077. (t)
  2078. Tree_tTree t;
  2079. # endif
  2080. {
  2081.   struct S_11 yyTempo;
  2082.  
  2083.   if (t == Tree_NoTree) {
  2084.     return;
  2085.   }
  2086.   switch (t->U_1.V_1.Kind) {
  2087.   case Tree_Formal:;
  2088.     {
  2089.       register Tree_yFormal *W_59 = &t->U_1.V_86.Formal;
  2090.  
  2091.       IO_WriteS(Tree_f, (STRING)"  ", 2L);
  2092.       C_DefC(W_59->TypeDesc);
  2093.       IO_WriteS(Tree_f, (STRING)" ", 1L);
  2094.       Tree_WI(W_59->Name);
  2095.       IO_WriteS(Tree_f, (STRING)";", 1L);
  2096.       IO_WriteNl(Tree_f);
  2097.       Declare(W_59->Next);
  2098.       return;
  2099.     }
  2100.     break;
  2101.   case Tree_Param:;
  2102.     {
  2103.       register struct S_12 *W_60 = &yyTempo.U_1.V_1.yyR2;
  2104.  
  2105.       {
  2106.         register Tree_yParam *W_61 = &t->U_1.V_38.Param;
  2107.  
  2108.         W_60->Var = Semantics_IdentifyVar(Decls, W_61->Name);
  2109.         IO_WriteS(Tree_f, (STRING)"  ", 2L);
  2110.         C_DefC(W_60->Var->U_1.V_86.Formal.TypeDesc);
  2111.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  2112.         Tree_WI(W_61->Name);
  2113.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2114.         IO_WriteNl(Tree_f);
  2115.         Declare(W_61->Next);
  2116.         return;
  2117.       }
  2118.     }
  2119.     break;
  2120.   case Tree_ProcCall:;
  2121.     {
  2122.       register Tree_yProcCall *W_62 = &t->U_1.V_76.ProcCall;
  2123.  
  2124.       Declare(W_62->Call);
  2125.       Declare(W_62->Next);
  2126.       return;
  2127.     }
  2128.     break;
  2129.   case Tree_Condition:;
  2130.     {
  2131.       register Tree_yCondition *W_63 = &t->U_1.V_77.Condition;
  2132.  
  2133.       Declare(W_63->Expr);
  2134.       Declare(W_63->Next);
  2135.       return;
  2136.     }
  2137.     break;
  2138.   case Tree_Assignment:;
  2139.     {
  2140.       register Tree_yAssignment *W_64 = &t->U_1.V_78.Assignment;
  2141.  
  2142.       Declare(W_64->Adr);
  2143.       Declare(W_64->Expr);
  2144.       Declare(W_64->Next);
  2145.       return;
  2146.     }
  2147.     break;
  2148.   case Tree_TargetStmt:;
  2149.     {
  2150.       register Tree_yTargetStmt *W_65 = &t->U_1.V_81.TargetStmt;
  2151.  
  2152.       Declare(W_65->Parameters);
  2153.       Declare(W_65->Next);
  2154.       return;
  2155.     }
  2156.     break;
  2157.   case Tree_Statement:;
  2158.   case Tree_Reject:;
  2159.   case Tree_Fail:;
  2160.   case Tree_Nl:;
  2161.   case Tree_WriteStr:;
  2162.     {
  2163.       register Tree_yStatement *W_66 = &t->U_1.V_75.Statement;
  2164.  
  2165.       Declare(W_66->Next);
  2166.       return;
  2167.     }
  2168.     break;
  2169.   case Tree_OnePattern:;
  2170.     {
  2171.       register Tree_yOnePattern *W_67 = &t->U_1.V_45.OnePattern;
  2172.  
  2173.       if (W_67->Pattern->U_1.V_49.Pattern.Tempo != Idents_NoIdent && W_67->Pattern->U_1.V_1.Kind != Tree_DontCare1) {
  2174.         IO_WriteS(Tree_f, (STRING)"  ", 2L);
  2175.         C_DefC(W_67->Pattern->U_1.V_49.Pattern.TypeDesc);
  2176.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  2177.         Tree_WI(W_67->Pattern->U_1.V_49.Pattern.Tempo);
  2178.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2179.         IO_WriteNl(Tree_f);
  2180.       }
  2181.       Declare(W_67->Pattern);
  2182.       Declare(W_67->Next);
  2183.       return;
  2184.     }
  2185.     break;
  2186.   case Tree_OneExpr:;
  2187.   case Tree_NamedExpr:;
  2188.     {
  2189.       register Tree_yOneExpr *W_68 = &t->U_1.V_58.OneExpr;
  2190.  
  2191.       Declare(W_68->Expr);
  2192.       Declare(W_68->Next);
  2193.       return;
  2194.     }
  2195.     break;
  2196.   case Tree_Decompose:;
  2197.     {
  2198.       register Tree_yDecompose *W_69 = &t->U_1.V_50.Decompose;
  2199.  
  2200.       Declare(W_69->Patterns);
  2201.       return;
  2202.     }
  2203.     break;
  2204.   case Tree_DontCare:;
  2205.     {
  2206.       register Tree_yDontCare *W_70 = &t->U_1.V_54.DontCare;
  2207.  
  2208.       Declare(W_70->Tempos);
  2209.       return;
  2210.     }
  2211.     break;
  2212.   case Tree_DontCare1:;
  2213.     {
  2214.       register Tree_yDontCare1 *W_71 = &t->U_1.V_53.DontCare1;
  2215.  
  2216.       if (W_71->Tempo != Idents_NoIdent) {
  2217.         IO_WriteS(Tree_f, (STRING)"  ", 2L);
  2218.         C_DefC(W_71->TypeDesc);
  2219.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  2220.         Tree_WI(W_71->Tempo);
  2221.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2222.         IO_WriteNl(Tree_f);
  2223.       }
  2224.       return;
  2225.     }
  2226.     break;
  2227.   case Tree_Value:;
  2228.     {
  2229.       register Tree_yValue *W_72 = &t->U_1.V_55.Value;
  2230.  
  2231.       Declare(W_72->Expr);
  2232.       return;
  2233.     }
  2234.     break;
  2235.   case Tree_Compose:;
  2236.     {
  2237.       register Tree_yCompose *W_73 = &t->U_1.V_61.Compose;
  2238.  
  2239.       if (W_73->Tempo != Idents_NoIdent) {
  2240.         IO_WriteS(Tree_f, (STRING)"  register ", 11L);
  2241.         C_DefC(W_73->TypeDesc);
  2242.         IO_WriteS(Tree_f, (STRING)" ", 1L);
  2243.         Tree_WI(W_73->Tempo);
  2244.         IO_WriteS(Tree_f, (STRING)";", 1L);
  2245.         IO_WriteNl(Tree_f);
  2246.       }
  2247.       Declare(W_73->Exprs);
  2248.       return;
  2249.     }
  2250.     break;
  2251.   case Tree_Call:;
  2252.     {
  2253.       register Tree_yCall *W_74 = &t->U_1.V_65.Call;
  2254.  
  2255.       Declare(W_74->Expr);
  2256.       Declare(W_74->Exprs);
  2257.       Declare(W_74->Patterns);
  2258.       return;
  2259.     }
  2260.     break;
  2261.   case Tree_Binary:;
  2262.     {
  2263.       register Tree_yBinary *W_75 = &t->U_1.V_66.Binary;
  2264.  
  2265.       Declare(W_75->Lop);
  2266.       Declare(W_75->Rop);
  2267.       return;
  2268.     }
  2269.     break;
  2270.   case Tree_PreOperator:;
  2271.     {
  2272.       register Tree_yPreOperator *W_76 = &t->U_1.V_67.PreOperator;
  2273.  
  2274.       Declare(W_76->Expr);
  2275.       return;
  2276.     }
  2277.     break;
  2278.   case Tree_PostOperator:;
  2279.     {
  2280.       register Tree_yPostOperator *W_77 = &t->U_1.V_68.PostOperator;
  2281.  
  2282.       Declare(W_77->Expr);
  2283.       return;
  2284.     }
  2285.     break;
  2286.   case Tree_Parents:;
  2287.     {
  2288.       register Tree_yParents *W_78 = &t->U_1.V_70.Parents;
  2289.  
  2290.       Declare(W_78->Expr);
  2291.       return;
  2292.     }
  2293.     break;
  2294.   case Tree_Index:;
  2295.     {
  2296.       register Tree_yIndex *W_79 = &t->U_1.V_69.Index;
  2297.  
  2298.       Declare(W_79->Expr);
  2299.       Declare(W_79->Exprs);
  2300.       return;
  2301.     }
  2302.     break;
  2303.   default :
  2304.     break;
  2305.   }
  2306. }
  2307.  
  2308. static void Tg1
  2309. # ifdef __STDC__
  2310. (Tree_tTree t)
  2311. # else
  2312. (t)
  2313. Tree_tTree t;
  2314. # endif
  2315. {
  2316.   struct S_13 yyTempo;
  2317.  
  2318.   if (t == Tree_NoTree) {
  2319.     return;
  2320.   }
  2321.   if (t->U_1.V_1.Kind == Tree_Formal) {
  2322.     {
  2323.       register Tree_yFormal *W_80 = &t->U_1.V_86.Formal;
  2324.  
  2325.       TheName = W_80->Name;
  2326.       Tg1(W_80->TypeDesc);
  2327.       Tg1(W_80->Next);
  2328.       return;
  2329.     }
  2330.   }
  2331.   if (t->U_1.V_1.Kind == Tree_NodeTypes) {
  2332.     {
  2333.       register Tree_yNodeTypes *W_81 = &t->U_1.V_89.NodeTypes;
  2334.  
  2335.       IO_WriteS(Tree_f, (STRING)"  if (", 6L);
  2336.       Tree_WI(TheName);
  2337.       IO_WriteS(Tree_f, (STRING)" == No", 6L);
  2338.       Tree_WI(W_81->TreeName->U_1.V_29.TreeName.Name);
  2339.       IO_WriteS(Tree_f, (STRING)") return", 8L);
  2340.       if (RoutineKind == kPredicate) {
  2341.         IO_WriteS(Tree_f, (STRING)" false", 6L);
  2342.       }
  2343.       IO_WriteS(Tree_f, (STRING)";", 1L);
  2344.       IO_WriteNl(Tree_f);
  2345.       return;
  2346.     }
  2347.   }
  2348. }
  2349.  
  2350. static void CommonTestElim
  2351. # ifdef __STDC__
  2352. (Tree_tTree t)
  2353. # else
  2354. (t)
  2355. Tree_tTree t;
  2356. # endif
  2357. {
  2358.   struct S_14 yyTempo;
  2359.  
  2360.   if (t == Tree_NoTree) {
  2361.     return;
  2362.   }
  2363.   switch (t->U_1.V_1.Kind) {
  2364.   case Tree_Decision:;
  2365.     {
  2366.       register Tree_yDecision *W_82 = &t->U_1.V_105.Decision;
  2367.  
  2368.       if (W_82->Cases == 0) {
  2369.         if (!TemposDone && W_82->OneTest->U_1.V_1.Kind == Tree_TestValue && Optimize_NeedsTempo(W_82->Then, &rule)) {
  2370.           IO_WriteS(Tree_f, (STRING)" {", 2L);
  2371.           IO_WriteNl(Tree_f);
  2372.           TemposDone = TRUE;
  2373.           {
  2374.             register Tree_yRule *W_83 = &rule->U_1.V_42.Rule;
  2375.  
  2376.             RuleCount = W_83->Index;
  2377.             Decls = W_83->VarDecls;
  2378.             Declare(W_83->Patterns);
  2379.             Declare(W_83->Exprs);
  2380.             Declare(W_83->Statements);
  2381.           }
  2382.           CommonTestElim(W_82->OneTest);
  2383.           CommonTestElim(W_82->Then);
  2384.           IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2385.           IO_WriteNl(Tree_f);
  2386.           IO_WriteS(Tree_f, (STRING)" }", 2L);
  2387.           IO_WriteNl(Tree_f);
  2388.         } else {
  2389.           Optimize_GetRule(W_82->Then, &rule);
  2390.           Decls = rule->U_1.V_42.Rule.VarDecls;
  2391.           CommonTestElim(W_82->OneTest);
  2392.           CommonTestElim(W_82->Then);
  2393.           IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2394.           IO_WriteNl(Tree_f);
  2395.         }
  2396.         if (W_82->OneTest->U_1.V_1.Kind == Tree_TestValue && W_82->OneTest->U_1.V_102.TestValue.TypeDesc->U_1.V_1.Kind == Tree_UserType && Sets_IsElement((LONGCARD)W_82->OneTest->U_1.V_102.TestValue.TypeDesc->U_1.V_90.UserType.Type, &Semantics_UserTypes)) {
  2397.           IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2398.           IO_WriteNl(Tree_f);
  2399.         }
  2400.         TemposDone = FALSE;
  2401.         CommonTestElim(W_82->Else);
  2402.       } else {
  2403.         i = W_82->Cases;
  2404.         Case(t);
  2405.       }
  2406.       return;
  2407.     }
  2408.     break;
  2409.   case Tree_Decided:;
  2410.     {
  2411.       register Tree_yDecided *W_84 = &t->U_1.V_106.Decided;
  2412.  
  2413.       CommonTestElim(W_84->Rule);
  2414.       if (W_84->Rule->U_1.V_42.Rule.HasExit) {
  2415.         TemposDone = FALSE;
  2416.         CommonTestElim(W_84->Else);
  2417.       }
  2418.       return;
  2419.     }
  2420.     break;
  2421.   case Tree_TestKind:;
  2422.     {
  2423.       register Tree_yTestKind *W_85 = &t->U_1.V_98.TestKind;
  2424.  
  2425.       IO_WriteS(Tree_f, (STRING)"  if (", 6L);
  2426.       C_ImplC(W_85->Path);
  2427.       IO_WriteS(Tree_f, (STRING)"->Kind == k", 11L);
  2428.       Tree_WI(W_85->Name);
  2429.       IO_WriteS(Tree_f, (STRING)") {", 3L);
  2430.       IO_WriteNl(Tree_f);
  2431.       return;
  2432.     }
  2433.     break;
  2434.   case Tree_TestIsType:;
  2435.     {
  2436.       register Tree_yTestIsType *W_86 = &t->U_1.V_99.TestIsType;
  2437.  
  2438.       IO_WriteS(Tree_f, (STRING)"  if (", 6L);
  2439.       Tree_WI(W_86->TypeDesc->U_1.V_89.NodeTypes.TreeName->U_1.V_29.TreeName.Name);
  2440.       IO_WriteS(Tree_f, (STRING)"_IsType (", 9L);
  2441.       C_ImplC(W_86->Path);
  2442.       IO_WriteS(Tree_f, (STRING)", k", 3L);
  2443.       Tree_WI(W_86->Name);
  2444.       IO_WriteS(Tree_f, (STRING)")) {", 4L);
  2445.       IO_WriteNl(Tree_f);
  2446.       return;
  2447.     }
  2448.     break;
  2449.   case Tree_TestNil:;
  2450.     {
  2451.       register Tree_yTestNil *W_87 = &t->U_1.V_100.TestNil;
  2452.  
  2453.       IO_WriteS(Tree_f, (STRING)"  if (", 6L);
  2454.       C_ImplC(W_87->Path);
  2455.       IO_WriteS(Tree_f, (STRING)" == NULL) {", 11L);
  2456.       IO_WriteNl(Tree_f);
  2457.       return;
  2458.     }
  2459.     break;
  2460.   case Tree_TestNonlin:;
  2461.     {
  2462.       register Tree_yTestNonlin *W_88 = &t->U_1.V_101.TestNonlin;
  2463.  
  2464.       IO_WriteS(Tree_f, (STRING)"  if (equal", 11L);
  2465.       C_DefC(W_88->TypeDesc);
  2466.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  2467.       C_ImplC(W_88->Path);
  2468.       IO_WriteS(Tree_f, (STRING)", ", 2L);
  2469.       C_ImplC(W_88->Path2);
  2470.       IO_WriteS(Tree_f, (STRING)")) {", 4L);
  2471.       IO_WriteNl(Tree_f);
  2472.       return;
  2473.     }
  2474.     break;
  2475.   case Tree_TestValue:;
  2476.     if (t->U_1.V_102.TestValue.TypeDesc->U_1.V_1.Kind == Tree_UserType) {
  2477.       for (;;) {
  2478.         {
  2479.           register Tree_yTestValue *W_89 = &t->U_1.V_102.TestValue;
  2480.  
  2481.           if (!Sets_IsElement((LONGCARD)t->U_1.V_102.TestValue.TypeDesc->U_1.V_90.UserType.Type, &Semantics_UserTypes)) {
  2482.             goto EXIT_1;
  2483.           }
  2484.           AssignTempo(W_89->Expr);
  2485.           IO_WriteS(Tree_f, (STRING)"  {", 3L);
  2486.           C_DefC(W_89->TypeDesc);
  2487.           IO_WriteS(Tree_f, (STRING)" yyT; yyT = ", 12L);
  2488.           Expression(W_89->Expr);
  2489.           IO_WriteS(Tree_f, (STRING)";", 1L);
  2490.           IO_WriteNl(Tree_f);
  2491.           MatchExpr(W_89->Expr);
  2492.           IO_WriteS(Tree_f, (STRING)"  if (equal", 11L);
  2493.           C_DefC(W_89->TypeDesc);
  2494.           IO_WriteS(Tree_f, (STRING)" (", 2L);
  2495.           C_ImplC(W_89->Path);
  2496.           IO_WriteS(Tree_f, (STRING)", yyT)) {", 9L);
  2497.           IO_WriteNl(Tree_f);
  2498.           return;
  2499.         }
  2500.       } EXIT_1:;
  2501.     }
  2502.     {
  2503.       register Tree_yTestValue *W_90 = &t->U_1.V_102.TestValue;
  2504.  
  2505.       AssignTempo(W_90->Expr);
  2506.       IO_WriteS(Tree_f, (STRING)"  if (equal", 11L);
  2507.       C_DefC(W_90->TypeDesc);
  2508.       IO_WriteS(Tree_f, (STRING)" (", 2L);
  2509.       C_ImplC(W_90->Path);
  2510.       IO_WriteS(Tree_f, (STRING)", ", 2L);
  2511.       Expression(W_90->Expr);
  2512.       IO_WriteS(Tree_f, (STRING)")) {", 4L);
  2513.       IO_WriteNl(Tree_f);
  2514.       MatchExpr(W_90->Expr);
  2515.       return;
  2516.     }
  2517.     break;
  2518.   case Tree_Rule:;
  2519.     {
  2520.       register Tree_yRule *W_91 = &t->U_1.V_42.Rule;
  2521.  
  2522.       WriteLine(W_91->Line);
  2523.       RuleCount = W_91->Index;
  2524.       WithCount = 0;
  2525.       Decls = W_91->VarDecls;
  2526.       if (W_91->HasTempos && !TemposDone) {
  2527.         IO_WriteS(Tree_f, (STRING)" {", 2L);
  2528.         IO_WriteNl(Tree_f);
  2529.         Declare(W_91->Patterns);
  2530.         Declare(W_91->Exprs);
  2531.         Declare(W_91->Statements);
  2532.       }
  2533.       if (W_91->Statements->U_1.V_1.Kind != Tree_NoStatement) {
  2534.         IO_WriteS(Tree_f, (STRING)"  {", 3L);
  2535.         IO_WriteNl(Tree_f);
  2536.         C_ImplC(W_91->Statements);
  2537.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2538.         IO_WriteNl(Tree_f);
  2539.       }
  2540.       if (!W_91->HasRejectOrFail) {
  2541.         AssignFormals(W_91->Exprs, OutFormals);
  2542.         switch (RoutineKind) {
  2543.         case kProcedure:;
  2544.           IO_WriteS(Tree_f, (STRING)"   return;", 10L);
  2545.           IO_WriteNl(Tree_f);
  2546.           break;
  2547.         case kFunction:;
  2548.           if (W_91->HasPatterns && W_91->Expr->U_1.V_1.Kind != Tree_Compose && t->U_1.V_1.Kind != Tree_DontCare1) {
  2549.             IO_WriteS(Tree_f, (STRING)"  {register ", 12L);
  2550.             C_DefC(ReturnFormals->U_1.V_86.Formal.TypeDesc);
  2551.             IO_WriteS(Tree_f, (STRING)" ", 1L);
  2552.             Tree_WI(W_91->Tempo);
  2553.             IO_WriteS(Tree_f, (STRING)";", 1L);
  2554.             IO_WriteNl(Tree_f);
  2555.             Declare(W_91->Expr);
  2556.             AssignTempo(W_91->Expr);
  2557.             IO_WriteS(Tree_f, (STRING)"   ", 3L);
  2558.             Tree_WI(W_91->Tempo);
  2559.             IO_WriteS(Tree_f, (STRING)" = ", 3L);
  2560.             Expression(W_91->Expr);
  2561.             IO_WriteS(Tree_f, (STRING)";", 1L);
  2562.             IO_WriteNl(Tree_f);
  2563.             MatchExpr(W_91->Expr);
  2564.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  2565.             Tree_WI(W_91->Tempo);
  2566.             IO_WriteS(Tree_f, (STRING)";", 1L);
  2567.             IO_WriteNl(Tree_f);
  2568.             IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2569.             IO_WriteNl(Tree_f);
  2570.           } else if (W_91->HasTempos) {
  2571.             IO_WriteS(Tree_f, (STRING)"  {", 3L);
  2572.             IO_WriteNl(Tree_f);
  2573.             Declare(W_91->Expr);
  2574.             AssignTempo(W_91->Expr);
  2575.             MatchExpr(W_91->Expr);
  2576.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  2577.             Expression(W_91->Expr);
  2578.             IO_WriteS(Tree_f, (STRING)";", 1L);
  2579.             IO_WriteNl(Tree_f);
  2580.             IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2581.             IO_WriteNl(Tree_f);
  2582.           } else {
  2583.             IO_WriteS(Tree_f, (STRING)"   return ", 10L);
  2584.             Expression(W_91->Expr);
  2585.             IO_WriteS(Tree_f, (STRING)";", 1L);
  2586.             IO_WriteNl(Tree_f);
  2587.           }
  2588.           break;
  2589.         case kPredicate:;
  2590.           IO_WriteS(Tree_f, (STRING)"   return true;", 15L);
  2591.           IO_WriteNl(Tree_f);
  2592.           break;
  2593.         }
  2594.       }
  2595.       if (W_91->HasTempos && !TemposDone) {
  2596.         IO_WriteS(Tree_f, (STRING)" }", 2L);
  2597.         IO_WriteNl(Tree_f);
  2598.       }
  2599.       if (W_91->HasExit || Optimize_NeedsMatch(W_91->Tests)) {
  2600.         IO_WriteS(Tree_f, (STRING)"yyL", 3L);
  2601.         Tree_WN(RuleCount);
  2602.         IO_WriteS(Tree_f, (STRING)":;", 2L);
  2603.         IO_WriteNl(Tree_f);
  2604.       }
  2605.       IO_WriteNl(Tree_f);
  2606.       return;
  2607.     }
  2608.     break;
  2609.   default :
  2610.     break;
  2611.   }
  2612. }
  2613.  
  2614. static void Case
  2615. # ifdef __STDC__
  2616. (Tree_tTree t)
  2617. # else
  2618. (t)
  2619. Tree_tTree t;
  2620. # endif
  2621. {
  2622.   struct S_15 yyTempo;
  2623.  
  2624.   if (t == Tree_NoTree) {
  2625.     return;
  2626.   }
  2627.   if (t->U_1.V_1.Kind == Tree_Decision) {
  2628.     {
  2629.       register struct S_16 *W_92 = &yyTempo.U_1.V_1.yyR1;
  2630.  
  2631.       {
  2632.         register Tree_yDecision *W_93 = &t->U_1.V_105.Decision;
  2633.  
  2634.         IO_WriteNl(Tree_f);
  2635.         IO_WriteS(Tree_f, (STRING)"  switch (", 10L);
  2636.         C_ImplC(W_93->OneTest->U_1.V_97.OneTest.Path);
  2637.         IO_WriteS(Tree_f, (STRING)"->Kind) {", 9L);
  2638.         IO_WriteNl(Tree_f);
  2639.         W_92->n = i;
  2640.         while (W_92->n > 0) {
  2641.           if (!Sets_IsEmpty(t->U_1.V_105.Decision.OneTest->U_1.V_99.TestIsType.TypeDesc->U_1.V_89.NodeTypes.Types)) {
  2642.             Case(t->U_1.V_105.Decision.OneTest);
  2643.             CommonTestElim(t->U_1.V_105.Decision.Then);
  2644.             if (!Optimize_NeedsNoFinale(t->U_1.V_105.Decision.Then)) {
  2645.               IO_WriteS(Tree_f, (STRING)"  break;", 8L);
  2646.               IO_WriteNl(Tree_f);
  2647.             }
  2648.           }
  2649.           t = t->U_1.V_105.Decision.Else;
  2650.           DEC(W_92->n);
  2651.         }
  2652.         IO_WriteS(Tree_f, (STRING)"  }", 3L);
  2653.         IO_WriteNl(Tree_f);
  2654.         IO_WriteNl(Tree_f);
  2655.         CommonTestElim(t);
  2656.         return;
  2657.       }
  2658.     }
  2659.   }
  2660.   if (t->U_1.V_1.Kind == Tree_TestKind) {
  2661.     {
  2662.       register Tree_yTestKind *W_94 = &t->U_1.V_98.TestKind;
  2663.  
  2664.       IO_WriteS(Tree_f, (STRING)"  case k", 8L);
  2665.       Tree_WI(W_94->Name);
  2666.       IO_WriteS(Tree_f, (STRING)":", 1L);
  2667.       IO_WriteNl(Tree_f);
  2668.       return;
  2669.     }
  2670.   }
  2671.   if (t->U_1.V_1.Kind == Tree_TestIsType) {
  2672.     {
  2673.       register Tree_yTestIsType *W_95 = &t->U_1.V_99.TestIsType;
  2674.  
  2675.       Case(W_95->TypeDesc);
  2676.       return;
  2677.     }
  2678.   }
  2679.   if (t->U_1.V_1.Kind == Tree_NodeTypes) {
  2680.     {
  2681.       register Tree_yNodeTypes *W_96 = &t->U_1.V_89.NodeTypes;
  2682.  
  2683.       {
  2684.         LONGCARD B_3 = Sets_Minimum(&W_96->Types), B_4 = Sets_Maximum(&W_96->Types);
  2685.  
  2686.         if (B_3 <= B_4)
  2687.           for (j = B_3;; j += 1) {
  2688.             if (Sets_IsElement(j, &W_96->Types)) {
  2689.               TheClass = Semantics_LookupClass(W_96->TreeName->U_1.V_29.TreeName.Classes, j);
  2690.               IO_WriteS(Tree_f, (STRING)"  case k", 8L);
  2691.               Tree_WI(TheClass->U_1.V_5.Class.Name);
  2692.               IO_WriteS(Tree_f, (STRING)":", 1L);
  2693.               IO_WriteNl(Tree_f);
  2694.             }
  2695.             if (j >= B_4) break;
  2696.           }
  2697.       }
  2698.       return;
  2699.     }
  2700.   }
  2701. }
  2702.  
  2703. void C_BeginC
  2704. # ifdef __STDC__
  2705. ()
  2706. # else
  2707. ()
  2708. # endif
  2709. {
  2710. }
  2711.  
  2712. void C_CloseC
  2713. # ifdef __STDC__
  2714. ()
  2715. # else
  2716. ()
  2717. # endif
  2718. {
  2719. }
  2720.  
  2721. static void yyExit
  2722. # ifdef __STDC__
  2723. ()
  2724. # else
  2725. ()
  2726. # endif
  2727. {
  2728.   IO_CloseIO();
  2729.   Exit(1L);
  2730. }
  2731.  
  2732. void BEGIN_C()
  2733. {
  2734.   static BOOLEAN has_been_called = FALSE;
  2735.  
  2736.   if (!has_been_called) {
  2737.     has_been_called = TRUE;
  2738.  
  2739.     BEGIN_IO();
  2740.     BEGIN_Tree();
  2741.     BEGIN_System();
  2742.     BEGIN_IO();
  2743.     BEGIN_Tree();
  2744.     BEGIN_Positions();
  2745.     BEGIN_IO();
  2746.     BEGIN_Strings();
  2747.     BEGIN_StringMem();
  2748.     BEGIN_Idents();
  2749.     BEGIN_Texts();
  2750.     BEGIN_Sets();
  2751.     BEGIN_Semantics();
  2752.     BEGIN_Optimize();
  2753.     BEGIN_Tree();
  2754.  
  2755.     C_yyf = IO_StdOutput;
  2756.     C_Exit = yyExit;
  2757.     C_BeginC();
  2758.   }
  2759. }
  2760.